parlour 4.0.1 → 5.0.0.beta.1

data/lib/parlour/typed_object.rb

@@ -0,0 +1,87 @@
+# typed: true
+module Parlour
+  # A generic superclass of all objects which form part of type definitions in,
+  # specific formats, such as RbiObject and RbsObject.
+  class TypedObject
+    extend T::Sig
+    extend T::Helpers
+    abstract!
+
+    sig { params(name: String).void }
+    # Create a new typed object.
+    def initialize(name)
+      @name = name
+      @comments = []
+    end
+
+    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 RBS
+    # file.
+    # @return [Array<String>]
+    attr_reader :comments
+
+    sig { params(comment: T.any(String, T::Array[String])).void }
+    # Adds one or more comments to this RBS 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 { 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
+    
+    protected
+
+    sig do
+      params(
+        indent_level: Integer,
+        options: Options
+      ).returns(T::Array[String])
+    end
+    # Generates the RBS lines for this object's comments.
+    #
+    # @param indent_level [Integer] The indentation level to generate the lines at.
+    # @param options [Options] The formatting options to use.
+    # @return [Array<String>] The RBS lines for each comment, formatted as specified.
+    def generate_comments(indent_level, options)
+      comments.any? \
+        ? comments.map { |c| options.indented(indent_level, "# #{c}") }
+        : []
+    end
+  end
+end

data/lib/parlour/types.rb

@@ -0,0 +1,445 @@
+# typed: true
+
+module Parlour
+  # Contains structured types which can be used in type signatures.
+  module Types
+    TypeLike = T.type_alias { T.any(String, Type) }
+
+    # The top-level, abstract class for a generalised type. All of the other
+    # types inherit from this. Do not instantiate.
+    class Type
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { abstract.returns(String) }
+      def generate_rbi; end
+
+      sig { abstract.returns(String) }
+      def generate_rbs; end
+
+      sig { params(type_like: TypeLike).returns(Type) }
+      def self.to_type(type_like)
+        if type_like.is_a?(String)
+          Raw.new(type_like)
+        else
+          type_like
+        end
+      end
+
+      sig { params(type_like: TypeLike).returns(Type) }
+      def to_type(type_like)
+        Type.to_type(type_like)
+      end
+    end
+
+    # A basic type as a raw string.
+    class Raw < Type
+      sig { params(str: String).void }
+      def initialize(str)
+        @str = str
+      end
+
+      sig { returns(String) }
+      attr_reader :str
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        Raw === other && str == other.str
+      end
+
+      sig { override.returns(String) }
+      def generate_rbi
+        str
+      end
+
+      sig { override.returns(String) }
+      def generate_rbs
+        str
+      end
+    end
+
+    # A type which can be either the wrapped type, or nil.
+    class Nilable < Type
+      sig { params(type: TypeLike).void }
+      def initialize(type)
+        @type = to_type(type)
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        Nilable === other && type == other.type
+      end
+
+      sig { returns(Type) }
+      attr_reader :type
+
+      sig { override.returns(String) }
+      def generate_rbi
+        "T.nilable(#{type.generate_rbi})"
+      end
+
+      sig { override.returns(String) }
+      def generate_rbs
+        "#{type.generate_rbs}?"
+      end
+    end
+
+    # A type which is (at least) one of the wrapped types.
+    class Union < Type
+      sig { params(types: T::Array[TypeLike]).void }
+      def initialize(types)
+        @types = types.map(&method(:to_type))
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        Union === other && types == other.types
+      end
+
+      sig { returns(T::Array[Type]) }
+      attr_reader :types
+
+      sig { override.returns(String) }
+      def generate_rbi
+        "T.any(#{types.map(&:generate_rbi).join(', ')})"
+      end
+
+      sig { override.returns(String) }
+      def generate_rbs
+        "(#{types.map(&:generate_rbs).join(' | ')})"
+      end
+    end
+
+    # A type which matches all of the wrapped types.
+    class Intersection < Type
+      sig { params(types: T::Array[TypeLike]).void }
+      def initialize(types)
+        @types = types.map(&method(:to_type))
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        Intersection === other && types == other.types
+      end
+
+      sig { returns(T::Array[Type]) }
+      attr_reader :types
+
+      sig { override.returns(String) }
+      def generate_rbi
+        "T.all(#{types.map(&:generate_rbi).join(', ')})"
+      end
+
+      sig { override.returns(String) }
+      def generate_rbs
+        "(#{types.map(&:generate_rbs).join(' & ')})"
+      end
+    end
+
+    # A fixed-length array of items, each with a known type.
+    class Tuple < Type
+      sig { params(types: T::Array[TypeLike]).void }
+      def initialize(types)
+        @types = types.map(&method(:to_type))
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        Tuple === other && types == other.types
+      end
+
+      sig { returns(T::Array[Type]) }
+      attr_reader :types
+
+      sig { override.returns(String) }
+      def generate_rbi
+        "[#{types.map(&:generate_rbi).join(', ')}]"
+      end
+
+      sig { override.returns(String) }
+      def generate_rbs
+        "[#{types.map(&:generate_rbs).join(', ')}]"
+      end
+    end
+
+    class SingleElementCollection < Type
+      abstract!
+
+      sig { params(element: TypeLike).void }
+      def initialize(element)
+        @element = to_type(element)
+      end
+
+      sig { returns(Type) }
+      attr_reader :element
+
+      sig { abstract.returns(String) }
+      def collection_name; end
+
+      sig { override.returns(String) }
+      def generate_rbi
+        "T::#{collection_name}[#{element.generate_rbi}]"
+      end
+
+      sig { override.returns(String) }
+      def generate_rbs
+        "#{collection_name}[#{element.generate_rbs}]"
+      end
+    end
+
+    # An array with known element types.
+    class Array < SingleElementCollection
+      sig { override.returns(String) }
+      def collection_name
+        'Array'
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        Array === other && element == other.element
+      end
+    end
+
+    # A set with known element types.
+    class Set < SingleElementCollection
+      sig { override.returns(String) }
+      def collection_name
+        'Set'
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        Set === other && element == other.element
+      end
+    end
+
+    # A range with known element types.
+    class Range < SingleElementCollection
+      sig { override.returns(String) }
+      def collection_name
+        'Range'
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        Range === other && element == other.element
+      end
+    end
+
+    # An enumerable with known element types.
+    class Enumerable < SingleElementCollection
+      sig { override.returns(String) }
+      def collection_name
+        'Enumerable'
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        Enumerable === other && element == other.element
+      end
+    end
+
+    # An enumerator with known element types.
+    class Enumerator < SingleElementCollection
+      sig { override.returns(String) }
+      def collection_name
+        'Enumerator'
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        Enumerator === other && element == other.element
+      end
+    end
+
+    # A hash with known key and value types.
+    class Hash < Type
+      sig { params(key: TypeLike, value: TypeLike).void }
+      def initialize(key, value)
+        @key = to_type(key)
+        @value = to_type(value)
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        Hash === other && key == other.key && value == other.value
+      end
+
+      sig { returns(Type) }
+      attr_reader :key
+
+      sig { returns(Type) }
+      attr_reader :value
+
+      sig { override.returns(String) }
+      def generate_rbi
+        "T::Hash[#{key.generate_rbi}, #{value.generate_rbi}]"
+      end
+
+      sig { override.returns(String) }
+      def generate_rbs
+        "Hash[#{key.generate_rbs}, #{value.generate_rbs}]"
+      end
+    end
+
+    # A record/shape; a hash with a fixed set of keys with given types.
+    class Record < Type
+      sig { params(keys_to_types: T::Hash[Symbol, TypeLike]).void }
+      def initialize(keys_to_types)
+        @keys_to_types = keys_to_types.map do |k, v|
+          [k, to_type(v)]
+        end.to_h
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        Record === other && keys_to_types == other.keys_to_types
+      end
+
+      sig { returns(T::Hash[Symbol, Type]) }
+      attr_reader :keys_to_types
+
+      sig { override.returns(String) }
+      def generate_rbi
+        "{ #{keys_to_types.map { |k, v| "#{k}: #{v.generate_rbi}" }.join(', ')} }"
+      end
+
+      sig { override.returns(String) }
+      def generate_rbs
+        "{ #{keys_to_types.map { |k, v| "#{k}: #{v.generate_rbs}" }.join(', ')} }"
+      end
+    end
+
+    # A type which represents the class of a type, rather than an instance.
+    # For example, "String" means an instance of String, but "Class(String)"
+    # means the actual String class.
+    class Class < Type
+      sig { params(type: TypeLike).void }
+      def initialize(type)
+        @type = to_type(type)
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        Class === other && type == other.type
+      end
+
+      sig { returns(Type) }
+      attr_reader :type
+
+      sig { override.returns(String) }
+      def generate_rbi
+        "T.class_of(#{type.generate_rbi})"
+      end
+
+      sig { override.returns(String) }
+      def generate_rbs
+        "singleton(#{type.generate_rbs})"
+      end
+    end
+
+    # Generic type for a boolean.
+    class Boolean < Type
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        Boolean === other
+      end
+
+      sig { override.returns(String) }
+      def generate_rbi
+        "T::Boolean"
+      end
+
+      sig { override.returns(String) }
+      def generate_rbs
+        "bool"
+      end
+    end
+
+    # The explicit lack of a type. 
+    class Untyped < Type
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        Untyped === other
+      end
+
+      sig { override.returns(String) }
+      def generate_rbi
+        "T.untyped"
+      end
+
+      sig { override.returns(String) }
+      def generate_rbs
+        "untyped"
+      end
+    end
+
+    # A type which can be called as a function.
+    class Proc < Type
+      # A parameter to a proc.
+      class Parameter
+        extend T::Sig
+
+        sig { params(name: String, type: TypeLike, default: T.nilable(String)).void }
+        def initialize(name, type, default = nil)
+          @name = name
+          @type = Type.to_type(type)
+          @default = default
+        end
+
+        sig { returns(String) }
+        attr_reader :name
+
+        sig { returns(Type) }
+        attr_reader :type
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :default
+
+        sig { params(other: Object).returns(T::Boolean) }
+        def ==(other)
+          Parameter === other && name == other.name && type == other.type &&
+            default == other.default
+        end  
+      end
+      
+      sig { params(parameters: T::Array[Parameter], return_type: T.nilable(TypeLike)).void }
+      def initialize(parameters, return_type)
+        @parameters = parameters
+        @return_type = return_type && to_type(return_type)
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        Proc === other && parameters == other.parameters && return_type == other.return_type
+      end
+
+      sig { returns(T::Array[Parameter]) }
+      attr_reader :parameters
+
+      sig { returns(T.nilable(Type)) }
+      attr_reader :return_type
+
+      sig { override.returns(String) }
+      def generate_rbi
+        rbi_params = parameters.map do |param|
+          RbiGenerator::Parameter.new(param.name, type: param.type, default: param.default)
+        end
+        "T.proc.params(#{rbi_params.map(&:to_sig_param).join(', ')}).#{
+          @return_type ? "returns(#{@return_type.generate_rbi})" : 'void'
+        }"
+      end
+
+      sig { override.returns(String) }
+      def generate_rbs
+        rbs_params = parameters.map do |param|
+          RbsGenerator::Parameter.new(param.name, type: param.type, required: param.default.nil?)
+        end
+        "(#{rbs_params.map(&:to_rbs_param).join(', ')}) -> #{return_type&.generate_rbs || 'void'}"
+      end
+    end
+  end
+end
+