parlour 4.0.1 → 5.0.0.beta.1

data/lib/parlour/conversion/converter.rb

@@ -0,0 +1,34 @@
+# typed: true
+require 'rainbow'
+
+module Parlour
+  module Conversion
+    # An abstract class which converts between the node trees of two type
+    # systems.
+    class Converter
+      extend T::Sig
+      extend T::Helpers
+      abstract!
+
+      def initialize
+        @warnings = []
+      end
+
+      sig { returns(T::Array[[String, TypedObject]]) }
+      attr_reader :warnings
+
+      sig { params(msg: String, node: RbiGenerator::RbiObject).void }
+      def add_warning(msg, node)
+        warnings << [msg, node]
+
+        return if $VERBOSE.nil?
+        class_name = T.must(self.class.name).split('::').last
+        print Rainbow("Parlour warning: ").yellow.dark.bold
+        print Rainbow("#{class_name}: ").magenta.bright.bold
+        puts msg
+        print Rainbow("    └ at object: ").blue.bright.bold
+        puts node.describe
+      end
+    end
+  end
+end

data/lib/parlour/conversion/rbi_to_rbs.rb

@@ -0,0 +1,223 @@
+# typed: true
+module Parlour
+  module Conversion
+    # Converts RBI types to RBS types.
+    class RbiToRbs < Converter
+      extend T::Sig
+
+      sig { params(rbs_gen: RbsGenerator).void }
+      def initialize(rbs_gen)
+        super()
+        @rbs_gen = rbs_gen
+      end
+
+      sig { returns(RbsGenerator) }
+      attr_reader :rbs_gen
+
+      sig { params(from: RbiGenerator::Namespace, to: RbsGenerator::Namespace).void }
+      def convert_all(from, to)
+        from.children.each do |child|
+          convert_object(child, to)
+        end        
+      end
+
+      sig do
+        params(
+          node: RbiGenerator::RbiObject,
+          new_parent: RbsGenerator::Namespace,
+        ).void
+      end
+      def convert_object(node, new_parent)        
+        case node
+        when RbiGenerator::StructClassNamespace
+          add_warning 'performing a one-way conversion of an RBI struct to RBS', node
+
+          klass = new_parent.create_class(node.name)
+          klass.add_comments(node.comments)
+
+          # Create a constructor
+          klass.create_method('initialize', [
+            RbsGenerator::MethodSignature.new(
+              node.props.map do |prop|
+                RbsGenerator::Parameter.new(
+                  "#{prop.name}:",
+                  type: prop.type,
+                  required: !prop.optional,
+                )
+              end,
+              nil,
+            )
+          ])
+
+          # Make each prop a getter (and setter, if not immutable) attribute
+          node.props.each do |prop|
+            klass.create_attribute(
+              prop.name,
+              kind: prop.immutable ? :reader : :accessor,
+              type: prop.type,
+            )
+          end
+
+          klass 
+
+        when RbiGenerator::EnumClassNamespace
+          add_warning 'performing a one-way conversion of an RBI enum to RBS', node
+
+          klass = new_parent.create_class(node.name)
+          klass.add_comments(node.comments)
+
+          # Define .values
+          klass.create_method('values', [
+            RbsGenerator::MethodSignature.new([], Types::Array.new(node.name))
+          ], class_method: true)
+
+          # Define each enum variant
+          node.enums.each do |variant|
+            # We don't care about any extra value
+            variant = variant[0] if Array === variant
+
+            klass.create_constant(variant, type: node.name)
+          end
+
+          klass
+
+        when RbiGenerator::Arbitrary
+          add_warning 'converting type of Arbitrary is likely to cause syntax errors; doing it anyway', node
+          new_parent.create_arbitrary(
+            code: node.code,
+          ).add_comments(node.comments)
+
+        when RbiGenerator::Attribute
+          if node.class_attribute
+            add_warning 'RBS does not support class attributes; dropping', node
+            return
+          end
+          new_parent.create_attribute(
+            node.name,
+            kind: node.kind,
+            type: node.type,
+          ).add_comments(node.comments)
+
+        when RbiGenerator::ClassNamespace
+          if node.abstract
+            add_warning 'RBS does not support abstract classes', node
+          end
+          klass = new_parent.create_class(
+            node.name,
+            superclass: node.superclass
+          )
+          klass.add_comments(node.comments)
+          node.children.each do |child|
+            convert_object(child, klass)
+          end
+
+        when RbiGenerator::Constant
+          if node.eigen_constant
+            add_warning 'RBS does not support constants on eigenclasses; dropping', node
+            return
+          end
+          new_parent.create_constant(
+            node.name,
+            type: node.value,
+          ).add_comments(node.comments)
+
+        when RbiGenerator::Extend
+          new_parent.create_extend(node.name).add_comments(node.comments)
+
+        when RbiGenerator::Include
+          new_parent.create_include(node.name).add_comments(node.comments)
+
+        when RbiGenerator::Method
+          # Convert parameters
+          parameters = node.parameters
+            .reject { |param| param.kind == :block }
+            .map do |param|
+              RbsGenerator::Parameter.new(
+                param.name,
+                type: param.type,
+                required: param.default.nil?
+              )
+            end
+
+          # Find block if there is one
+          block_param = node.parameters.find { |param| param.kind == :block }
+          if block_param
+            if String === block_param.type
+              add_warning "block must have a Types::Type for conversion; dropping block", node
+              block = nil
+            else
+              # A nilable proc is an optional block
+              block_param_type = block_param.type
+              if Types::Nilable === block_param_type && Types::Proc === block_param_type.type
+                t = T.cast(block_param_type.type, Types::Proc)
+                required = false
+                block = RbsGenerator::Block.new(t, required)
+              elsif Types::Proc === block_param_type
+                t = block_param_type
+                required = true
+                block = RbsGenerator::Block.new(t, required)
+              elsif Types::Untyped === block_param_type
+                # Consider there to be a block of unknown types
+                block = RbsGenerator::Block.new(
+                  Types::Proc.new(
+                    [
+                      Types::Proc::Parameter.new('*args', Types::Untyped.new),
+                      Types::Proc::Parameter.new('**kwargs', Types::Untyped.new),
+                    ],
+                    Types::Untyped.new,
+                  ),
+                  false,
+                )
+              else
+                add_warning 'block type must be a Types::Proc (or nilable one); dropping block', node
+              end
+            end
+          else
+            block = nil
+          end
+
+          new_parent.create_method(
+            node.name,
+            [
+              RbsGenerator::MethodSignature.new(
+                parameters,
+                node.return_type,
+                block: block,
+                type_parameters: node.type_parameters,
+              )
+            ],
+            class_method: node.class_method,
+          ).add_comments(node.comments)
+
+        when RbiGenerator::ModuleNamespace
+          if node.interface
+            rbs_node = new_parent.create_interface(
+              node.name,
+            )
+          else
+            rbs_node = new_parent.create_module(
+              node.name,
+            )
+          end
+          rbs_node.add_comments(node.comments)
+          node.children.each do |child|
+            convert_object(child, rbs_node)
+          end
+
+        when RbiGenerator::Namespace
+          add_warning 'unspecialized namespaces are not supposed to be in the tree; you may run into issues', node
+          namespace = RbsGenerator::Namespace.new(rbs_gen)
+          namespace.add_comments(node.comments)
+          node.children.each do |child|
+            convert_object(child, namespace)
+          end
+          new_parent.children << namespace
+
+        else
+          raise "missing conversion for #{node.describe}"
+          # TODO: stick a T.absurd here
+        end
+      end
+    end
+  end
+end

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/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