parlour 2.0.0 → 5.0.0.beta.1

data/lib/parlour/detached_rbi_generator.rb

@@ -6,17 +6,12 @@ module Parlour
     def detached!
       raise "cannot call methods on a detached RBI generator"
     end
-  
+
     sig { override.returns(Options) }
     def options
       detached!
     end
 
-    sig { override.returns(Namespace) }
-    def root
-      detached!
-    end
-
     sig { override.returns(T.nilable(Plugin)) }
     def current_plugin
       nil

data/lib/parlour/detached_rbs_generator.rb

@@ -0,0 +1,25 @@
+# typed: true
+
+module Parlour
+  class DetachedRbsGenerator < RbsGenerator
+    sig { returns(T.untyped) }
+    def detached!
+      raise "cannot call methods on a detached RBS generator"
+    end
+
+    sig { override.returns(Options) }
+    def options
+      detached!
+    end
+
+    sig { override.returns(T.nilable(Plugin)) }
+    def current_plugin
+      nil
+    end
+
+    sig { override.returns(String) }
+    def rbs
+      detached!
+    end
+  end
+end

data/lib/parlour/generator.rb

@@ -0,0 +1,34 @@
+# typed: true
+module Parlour
+  class Generator
+    extend T::Sig
+  
+    sig { params(break_params: Integer, tab_size: Integer, sort_namespaces: T::Boolean).void }
+    # Creates a new generator.
+    #
+    # @param break_params [Integer] If there are at least this many parameters in a 
+    #   signature, then it is broken onto separate lines.
+    # @param tab_size [Integer] The number of spaces to use per indent.
+    # @param sort_namespaces [Boolean] Whether to sort all items within a
+    #   namespace alphabetically.
+    # @return [void]
+    def initialize(break_params: 4, tab_size: 2, sort_namespaces: false)
+      @options = Options.new(
+        break_params: break_params,
+        tab_size: tab_size,
+        sort_namespaces: sort_namespaces
+      )
+    end
+
+    sig { overridable.returns(Options) }
+    # The formatting options for this generator. Currently ignored.
+    # @return [Options]
+    attr_reader :options
+
+    sig { overridable.returns(T.nilable(Plugin)) }
+    # The plugin which is currently generating new definitions.
+    # {Plugin#run_plugins} controls this value.
+    # @return [Plugin, nil]
+    attr_accessor :current_plugin
+  end
+end

data/lib/parlour/options.rb

@@ -0,0 +1,71 @@
+# typed: true
+module Parlour
+  # A set of immutable formatting options.
+  class Options
+    extend T::Sig
+
+    sig { params(break_params: Integer, tab_size: Integer, sort_namespaces: T::Boolean).void }
+    # Creates a new set of formatting options.
+    #
+    # @example Create Options with +break_params+ of +4+ and +tab_size+ of +2+.
+    #   Parlour::Options.new(break_params: 4, tab_size: 2)
+    #
+    # @param break_params [Integer] If there are at least this many parameters in a 
+    #   signature, then it is broken onto separate lines.
+    # @param tab_size [Integer] The number of spaces to use per indent.
+    # @param sort_namespaces [Boolean] Whether to sort all items within a
+    #   namespace alphabetically.
+    # @return [void]
+    def initialize(break_params:, tab_size:, sort_namespaces:)
+      @break_params = break_params
+      @tab_size = tab_size
+      @sort_namespaces = sort_namespaces
+    end
+    
+    sig { returns(Integer) }
+    # If there are at least this many parameters in a signature, then it 
+    # is broken onto separate lines.
+    #
+    #   # With break_params: 5
+    #   sig { params(name: String, age: Integer, hobbies: T::Array(String), country: Symbol).void }
+    #
+    #   # With break_params: 4
+    #   sig do
+    #     params(
+    #       name: String,
+    #       age: Integer,
+    #       hobbies: T::Array(String),
+    #       country: Symbol
+    #     ).void
+    #   end
+    #
+    # @return [Integer]
+    attr_reader :break_params
+
+    sig { returns(Integer) }
+    # The number of spaces to use per indent.
+    # @return [Integer]
+    attr_reader :tab_size
+
+    sig { returns(T::Boolean) }
+    # Whether to sort all items within a namespace alphabetically.
+    # Items which are typically grouped together, such as "include" or
+    # "extend" calls, will remain grouped together when sorted.
+    # If true, items are sorted by their name when the RBI is generated.
+    # If false, items are generated in the order they are added to the
+    # namespace.
+    # @return [Boolean]
+    attr_reader :sort_namespaces
+
+    sig { params(level: Integer, str: String).returns(String) }
+    # Returns a string indented to the given indent level, according to the
+    # set {tab_size}.
+    #
+    # @param level [Integer] The indent level, as an integer. 0 is totally unindented.
+    # @param str [String] The string to indent.
+    # @return [String] The indented string.
+    def indented(level, str)
+      " " * (level * tab_size) + str
+    end
+  end
+end

data/lib/parlour/plugin.rb

@@ -50,7 +50,7 @@ module Parlour
       end
     end
 
-    sig { params(options: Hash).void }
+    sig { params(options: T::Hash[T.untyped, T.untyped]).void }
     def initialize(options); end
 
     sig { abstract.params(root: RbiGenerator::Namespace).void }

data/lib/parlour/rbi_generator.rb

@@ -1,55 +1,42 @@
 # typed: true
 module Parlour
   # The RBI generator.
-  class RbiGenerator
-    extend T::Sig
+  class RbiGenerator < Generator
+    # For backwards compatibility.
+    # Before Parlour 5.0, Parlour::Options was Parlour::RbiGenerator::Options.
+    Options = Parlour::Options
 
-    sig { params(break_params: Integer, tab_size: Integer, sort_namespaces: T::Boolean).void }
-    # Creates a new RBI generator.
-    #
-    # @example Create a default generator.
-    #   generator = Parlour::RbiGenerator.new
-    # 
-    # @example Create a generator with a custom +tab_size+ of 3.
-    #   generator = Parlour::RbiGenerator.new(tab_size: 3)
-    #
-    # @param break_params [Integer] If there are at least this many parameters in a 
-    #   Sorbet +sig+, then it is broken onto separate lines.
-    # @param tab_size [Integer] The number of spaces to use per indent.
-    # @param sort_namespaces [Boolean] Whether to sort all items within a
-    #   namespace alphabetically.
-    # @return [void]
-    def initialize(break_params: 4, tab_size: 2, sort_namespaces: false)
-      @options = Options.new(
-        break_params: break_params,
-        tab_size: tab_size,
-        sort_namespaces: sort_namespaces
-      )
-      @root = Namespace.new(self)
+    def initialize(**hash)
+      super
+      @root = RbiGenerator::Namespace.new(self)
     end
 
-    sig { overridable.returns(Options) }
-    # The formatting options for this generator.
-    # @return [Options]
-    attr_reader :options
-
-    sig { overridable.returns(Namespace) }
+    sig { overridable.returns(RbiGenerator::Namespace) }
     # The root {Namespace} of this generator.
     # @return [Namespace]
     attr_reader :root
 
-    sig { overridable.returns(T.nilable(Plugin)) }
-    # The plugin which is currently generating new definitions.
-    # {Plugin#run_plugins} controls this value.
-    # @return [Plugin, nil]
-    attr_accessor :current_plugin
-
     sig { overridable.params(strictness: String).returns(String) }
     # Returns the complete contents of the generated RBI file as a string.
     #
     # @return [String] The generated RBI file
     def rbi(strictness = 'strong')
-      "# typed: #{strictness}\n" + root.generate_rbi(0, options).join("\n") + "\n"
+      # TODO: Early test option - convert to RBS if requested
+      # Absolutely remove this later on
+      if ENV['PARLOUR_CONVERT_TO_RBS']
+        # Perform conversion
+        root.generalize_from_rbi!
+        rbs_gen = Parlour::RbsGenerator.new
+        converter = Parlour::Conversion::RbiToRbs.new(rbs_gen)
+        root.children.each do |child|
+          converter.convert_object(child, rbs_gen.root)
+        end
+
+        # Write the final RBS
+        rbs_gen.rbs
+      else
+        "# typed: #{strictness}\n" + root.generate_rbi(0, options).join("\n") + "\n"
+      end
     end
   end
 end

data/lib/parlour/rbi_generator/arbitrary.rb

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

data/lib/parlour/rbi_generator/attribute.rb

@@ -1,14 +1,14 @@
 # typed: true
 module Parlour
-  class RbiGenerator
+  class RbiGenerator < Generator
     # Represents an attribute reader, writer or accessor.
     class Attribute < Method
       sig do
         params(
-          generator: RbiGenerator,
+          generator: Generator,
           name: String,
           kind: Symbol,
-          type: String,
+          type: Types::TypeLike,
           class_attribute: T::Boolean,
           block: T.nilable(T.proc.params(x: Attribute).void)
         ).void
@@ -20,8 +20,7 @@ module Parlour
       # @param name [String] The name of this attribute.
       # @param kind [Symbol] The kind of attribute this is; one of :writer, :reader or
       #   :accessor.
-      # @param type [String] A Sorbet string of this attribute's type, such as
-      #   +"String"+ or +"T.untyped"+.
+      # @param type [String, Types::Type] This attribute's type.
       # @param class_attribute [Boolean] Whether this attribute belongs to the
       #   singleton class.
       # @param block A block which the new instance yields itself to.
@@ -32,6 +31,7 @@ module Parlour
         # attr_accessor and attr_reader should have: sig { returns(X) }
         # attr_writer :foo should have: sig { params(foo: X).returns(X) }
 
+        @type = type
         @kind = kind
         @class_attribute = class_attribute
         case kind
@@ -55,6 +55,10 @@ module Parlour
       # Whether this attribute belongs to the singleton class.
       attr_reader :class_attribute
 
+      sig { returns(Types::TypeLike) }
+      # The type of this attribute.
+      attr_reader :type
+
       sig { override.params(other: Object).returns(T::Boolean) }
       # Returns true if this instance is equal to another attribute.
       #
@@ -69,6 +73,11 @@ module Parlour
         )
       end
 
+      sig { override.void }
+      def generalize_from_rbi!
+        @type = TypeParser.parse_single_type(@type) if String === @type
+      end
+
       private
 
       sig do

data/lib/parlour/rbi_generator/class_namespace.rb

@@ -1,13 +1,13 @@
 # typed: true
 module Parlour
-  class RbiGenerator
+  class RbiGenerator < Generator
     # Represents a class definition.
     class ClassNamespace < Namespace
       extend T::Sig
 
       sig do
         params(
-          generator: RbiGenerator,
+          generator: Generator,
           name: String,
           final: T::Boolean,
           superclass: T.nilable(String),
@@ -47,7 +47,7 @@ module Parlour
         class_definition = superclass.nil? \
           ? "class #{name}"
           : "class #{name} < #{superclass}"
-        
+    
         lines = generate_comments(indent_level, options)
         lines << options.indented(indent_level, class_definition)
         lines += [options.indented(indent_level + 1, "abstract!"), ""] if abstract
@@ -116,6 +116,11 @@ module Parlour
           "#{"abstract, " if abstract}#{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/constant.rb

@@ -1,13 +1,14 @@
 # typed: true
 module Parlour
-  class RbiGenerator
+  class RbiGenerator < Generator
     # Represents a constant definition.
     class Constant < RbiObject
       sig do
         params(
-          generator: RbiGenerator,
+          generator: Generator,
           name: String,
-          value: String,
+          value: Types::TypeLike,
+          eigen_constant: T::Boolean,
           block: T.nilable(T.proc.params(x: Constant).void)
         ).void
       end
@@ -15,16 +16,23 @@ module Parlour
       #
       # @param name [String] The name of the constant.
       # @param value [String] The value of the constant, as a Ruby code string.
-      def initialize(generator, name: '', value: '', &block)
+      # @param eigen_constant [Boolean] Whether this constant is defined on the
+      #   eigenclass of the current namespace.
+      def initialize(generator, name: '', value: '', eigen_constant: false, &block)
         super(generator, name)
         @value = value
+        @eigen_constant = eigen_constant
         yield_self(&block) if block
       end
 
-      # @return [String] The value of the constant, as a Ruby code string.
-      sig { returns(String) }
+      # @return [String] The value or type of the constant.
+      sig { returns(Types::TypeLike) }
       attr_reader :value
 
+      # @return [Boolean] Whether this constant is defined on the eigenclass
+      #   of the current namespace.
+      attr_reader :eigen_constant
+
       sig { params(other: Object).returns(T::Boolean) }
       # Returns true if this instance is equal to another extend.
       #
@@ -32,7 +40,8 @@ module Parlour
       #   subclass of it), this will always return false.
       # @return [Boolean]
       def ==(other)
-        Constant === other && name == other.name && value == other.value
+        Constant === other && name == other.name && value == other.value \
+          && eigen_constant == other.eigen_constant
       end
 
       sig do
@@ -47,7 +56,11 @@ 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)
-        [options.indented(indent_level, "#{name} = #{value}")]
+        if String === @value
+          [options.indented(indent_level, "#{name} = #{@value}")]
+        else
+          [options.indented(indent_level, "#{name} = T.let(nil, #{@value.generate_rbi})")]
+        end
       end
 
       sig do
@@ -89,6 +102,13 @@ module Parlour
       def describe
         "Constant (#{name} = #{value})"
       end
+
+      sig { override.void }
+      def generalize_from_rbi!
+        # There's a good change this is an untyped constant, so rescue
+        # ParseError and use untyped
+        @value = (TypeParser.parse_single_type(@value) if String === @value) rescue Types::Untyped.new
+      end
     end
   end
 end