parlour 2.0.0 → 5.0.0.beta.1

data/exe/parlour

@@ -16,15 +16,67 @@ command :run do |c|
   c.description = 'Generates an RBI file from your .parlour file'
 
   c.action do |args, options|
-    configuration = keys_to_symbols(YAML.load_file(File.join(Dir.pwd, '.parlour')))
+    working_dir = Dir.pwd
+    config_filename = File.join(working_dir, '.parlour')
 
-    raise 'you must specify output_file in your .parlour file' unless configuration[:output_file]
+    if File.exists?(config_filename)
+      configuration = keys_to_symbols(YAML.load_file(config_filename))
+    else
+      configuration = {}
+    end
+
+    # Output file
+    if configuration[:output_file].is_a?(String)
+      assumed_format = \
+        if configuration[:output_file].end_with?('.rbi')
+          :rbi
+        elsif configuration[:output_file].end_with?('.rbs')
+          :rbs
+        else
+          raise 'invalid output file; please specify an RBI or RBS file'
+        end
+
+      unless $VERBOSE.nil?
+        print Rainbow("Parlour warning: ").yellow.dark.bold
+        print Rainbow("CLI: ").magenta.bright.bold
+        puts "Specifying output_file in .parlour as a string is deprecated."
+        puts "For now, generating an #{assumed_format.to_s.upcase} file based on the file extension."
+        puts "Please update your .parlour to use the new form:"
+        puts "  output_file:"
+        puts "    #{assumed_format}: #{configuration[:output_file]}"
+      end
+      configuration[:output_file] = {
+        assumed_format => configuration[:output_file]
+      }
+    end
+    configuration[:output_file] ||= {
+      rbi: "rbi/#{File.basename(working_dir)}.rbi"
+    }    
 
     # Style defaults
     configuration[:style] ||= {}
     configuration[:style][:tab_size] ||= 2
     configuration[:style][:break_params] ||= 4
 
+    # Parser defaults, set explicitly to false to not run parser
+    if configuration[:parser] != false
+      configuration[:parser] ||= {}
+
+      # Input/Output defaults
+      configuration[:parser][:root] ||= '.'
+
+      # Included/Excluded path defaults
+      configuration[:parser][:included_paths] ||= ['lib']
+      configuration[:parser][:excluded_paths] ||= ['sorbet', 'spec']
+
+      # Defaults can be overridden but we always want to exclude the output file
+      configuration[:parser][:excluded_paths] << configuration[:output_file][:rbi]
+    end
+
+    # Included/Excluded module defaults
+    configuration[:included_modules] ||= []
+    configuration[:excluded_modules] ||= []
+
     # Require defaults
     configuration[:requires] ||= []
     configuration[:relative_requires] ||= []
@@ -53,6 +105,15 @@ command :run do |c|
       break_params: configuration[:style][:break_params],
       tab_size: configuration[:style][:tab_size]
     )
+
+    if configuration[:parser]
+      Parlour::TypeLoader.load_project(
+        configuration[:parser][:root],
+        inclusions: configuration[:parser][:included_paths],
+        exclusions: configuration[:parser][:excluded_paths],
+        generator: gen,
+      )
+    end
     Parlour::Plugin.run_plugins(plugin_instances, gen)
 
     # Run a pass of the conflict resolver
@@ -74,6 +135,14 @@ command :run do |c|
       choice == 0 ? nil : candidates[choice - 1]
     end
 
+    if !configuration[:included_modules].empty? || !configuration[:excluded_modules].empty?
+      remove_unwanted_modules(
+        gen.root,
+        included_modules: configuration[:included_modules],
+        excluded_modules: configuration[:excluded_modules],
+      )
+    end
+
     # Figure out strictness levels
     requested_strictness_levels = plugin_instances.map do |plugin|
       s = plugin.strictness&.to_s
@@ -97,8 +166,23 @@ command :run do |c|
       end
     end
 
-    # Write the final RBI
-    File.write(configuration[:output_file], gen.rbi(strictness))
+    # Write the final files
+    if configuration[:output_file][:rbi]
+      FileUtils.mkdir_p(File.dirname(configuration[:output_file][:rbi]))
+      File.write(configuration[:output_file][:rbi], gen.rbi(strictness))
+    end
+    if configuration[:output_file][:rbs]
+      gen.root.generalize_from_rbi!
+      rbs_gen = Parlour::RbsGenerator.new
+
+      converter = Parlour::Conversion::RbiToRbs.new(rbs_gen)
+      gen.root.children.each do |child|
+        converter.convert_object(child, rbs_gen.root)
+      end
+
+      FileUtils.mkdir_p(File.dirname(configuration[:output_file][:rbs]))
+      File.write(configuration[:output_file][:rbs], rbs_gen.rbs)
+    end
   end
 end
 
@@ -122,3 +206,24 @@ def keys_to_symbols(hash)
     ]
   end.to_h
 end
+
+def remove_unwanted_modules(root, included_modules:, excluded_modules:, prefix: nil)
+  root.children.select! do |child|
+    module_name = "#{prefix}#{child.name}"
+
+    if child.respond_to?(:children)
+      remove_unwanted_modules(
+        child,
+        included_modules: included_modules,
+        excluded_modules: excluded_modules,
+        prefix: "#{module_name}::",
+      )
+      has_included_children = !child.children.empty?
+    end
+
+    included = included_modules.empty? ? true : included_modules.any? { |m| module_name.start_with?(m) }
+    excluded = excluded_modules.empty? ? false : excluded_modules.any? { |m| module_name.start_with?(m) }
+
+    (included || has_included_children) && !excluded
+  end
+end

data/lib/parlour.rb

@@ -9,12 +9,17 @@ require 'parlour/kernel_hack'
 
 require 'parlour/plugin'
 
+require 'parlour/types'
+
+require 'parlour/options'
+require 'parlour/typed_object'
+require 'parlour/generator'
 require 'parlour/rbi_generator/parameter'
 require 'parlour/rbi_generator/rbi_object'
+require 'parlour/rbi_generator/type_alias'
 require 'parlour/rbi_generator/method'
 require 'parlour/rbi_generator/attribute'
 require 'parlour/rbi_generator/arbitrary'
-require 'parlour/rbi_generator/options'
 require 'parlour/rbi_generator/include'
 require 'parlour/rbi_generator/extend'
 require 'parlour/rbi_generator/constant'
@@ -22,9 +27,32 @@ require 'parlour/rbi_generator/namespace'
 require 'parlour/rbi_generator/module_namespace'
 require 'parlour/rbi_generator/class_namespace'
 require 'parlour/rbi_generator/enum_class_namespace'
+require 'parlour/rbi_generator/struct_prop'
+require 'parlour/rbi_generator/struct_class_namespace'
 require 'parlour/rbi_generator'
 require 'parlour/detached_rbi_generator'
 
+require 'parlour/rbs_generator/rbs_object'
+require 'parlour/rbs_generator/type_alias'
+require 'parlour/rbs_generator/namespace'
+require 'parlour/rbs_generator/method'
+require 'parlour/rbs_generator/arbitrary'
+require 'parlour/rbs_generator/attribute'
+require 'parlour/rbs_generator/block'
+require 'parlour/rbs_generator/class_namespace'
+require 'parlour/rbs_generator/constant'
+require 'parlour/rbs_generator/extend'
+require 'parlour/rbs_generator/include'
+require 'parlour/rbs_generator/method_signature'
+require 'parlour/rbs_generator/module_namespace'
+require 'parlour/rbs_generator/interface_namespace'
+require 'parlour/rbs_generator/parameter'
+require 'parlour/rbs_generator'
+require 'parlour/detached_rbs_generator'
+
+require 'parlour/conversion/converter'
+require 'parlour/conversion/rbi_to_rbs'
+
 require 'parlour/conflict_resolver'
 
 require 'parlour/parse_error'

data/lib/parlour/conflict_resolver.rb

@@ -1,4 +1,6 @@
 # typed: true
+require 'set'
+
 module Parlour
   # Responsible for resolving conflicts (that is, multiple definitions with the
   # same name) between objects defined in the same namespace.
@@ -11,7 +13,7 @@ module Parlour
         resolver: T.proc.params(
           desc: String,
           choices: T::Array[RbiGenerator::RbiObject]
-        ).returns(RbiGenerator::RbiObject)
+        ).returns(T.nilable(RbiGenerator::RbiObject))
       ).void
     end
     # Given a namespace, attempts to automatically resolve conflicts in the
@@ -21,13 +23,13 @@ module Parlour
     # All children of the given namespace which are also namespaces are
     # processed recursively, so passing {RbiGenerator#root} will eliminate all
     # conflicts in the entire object tree.
-    # 
+    #
     # If automatic resolution is not possible, the block passed to this method
     # is invoked and passed two arguments: a message on what the conflict is,
     # and an array of candidate objects. The block should return one of these
     # candidate objects, which will be kept, and all other definitions are
     # deleted. Alternatively, the block may return nil, which will delete all
-    # definitions. The block may be invoked many times from one call to 
+    # definitions. The block may be invoked many times from one call to
     # {resolve_conflicts}, one for each unresolvable conflict.
     #
     # @param namespace [RbiGenerator::Namespace] The starting namespace to
@@ -42,7 +44,14 @@ module Parlour
       Debugging.debug_puts(self, Debugging::Tree.begin("Resolving conflicts for #{namespace.name}..."))
 
       # Check for multiple definitions with the same name
-      grouped_by_name_children = namespace.children.group_by(&:name)
+      # (Special case here: writer attributes get an "=" appended to their name)
+      grouped_by_name_children = namespace.children.group_by do |child|
+        if RbiGenerator::Attribute === child && child.kind == :writer
+          "#{child.name}=" unless child.name.end_with?('=')
+        else
+          child.name
+        end
+      end
 
       grouped_by_name_children.each do |name, children|
         Debugging.debug_puts(self, Debugging::Tree.begin("Checking children named #{name}..."))
@@ -50,7 +59,7 @@ module Parlour
         if children.length > 1
           Debugging.debug_puts(self, Debugging::Tree.here("Possible conflict between #{children.length} objects"))
 
-          # Special case: do we have two methods, one of which is a class method 
+          # Special case: do we have two methods, one of which is a class method
           # and the other isn't? If so, do nothing - this is fine
           if children.length == 2 &&
             children.all? { |c| c.is_a?(RbiGenerator::Method) } &&
@@ -60,7 +69,22 @@ module Parlour
             next
           end
 
-          # Special case: do we have two attributes, one of which is a class 
+          # Special case: if we remove the namespaces, is everything either an
+          # include or an extend? If so, do nothing - this is fine
+          if children \
+            .reject { |c| c.is_a?(RbiGenerator::Namespace) }
+            .then do |x|
+              !x.empty? && x.all? do |c|
+                c.is_a?(RbiGenerator::Include) || c.is_a?(RbiGenerator::Extend)
+              end
+            end
+            deduplicate_mixins_of_name(namespace, name)
+
+            Debugging.debug_puts(self, Debugging::Tree.end("Includes/extends do not conflict with namespaces; no resolution required"))
+            next
+          end
+
+          # Special case: do we have two attributes, one of which is a class
           # attribute and the other isn't? If so, do nothing - this is fine
           if children.length == 2 &&
             children.all? { |c| c.is_a?(RbiGenerator::Attribute) } &&
@@ -70,13 +94,13 @@ module Parlour
             next
           end
 
-          # Special case: are they all clearly equal? If so, remove all but one
+          # Optimization for Special case: are they all clearly equal? If so, remove all but one
           if all_eql?(children)
             Debugging.debug_puts(self, Debugging::Tree.end("All children are identical"))
 
             # All of the children are the same, so this deletes all of them
             namespace.children.delete(T.must(children.first))
-          
+
             # Re-add one child
             namespace.children << T.must(children.first)
             next
@@ -117,14 +141,25 @@ module Parlour
                 choice = resolver.call("Non-namespace item in a differing namespace conflict is not a single method", non_namespaces)
                 non_namespaces = []
                 non_namespaces << choice if choice
-              end 
+              end
             end
 
             non_namespaces.each do |x|
               namespace.children << x
             end
 
-            first, *rest = namespaces
+            # For certain namespace types the order matters. For example, if there's
+            # both a `Namespace` and `ModuleNamespace` then merging the two would
+            # produce different results depending on which is first.
+            first_index = (
+              namespaces.find_index { |x| RbiGenerator::EnumClassNamespace === x || RbiGenerator::StructClassNamespace === x } ||
+              namespaces.find_index { |x| RbiGenerator::ClassNamespace === x } ||
+              namespaces.find_index { |x| RbiGenerator::ModuleNamespace === x } ||
+              0
+            )
+
+            first = namespaces.delete_at(first_index)
+            rest = namespaces
           else
             raise 'unknown merge strategy; this is a Parlour bug'
           end
@@ -161,16 +196,16 @@ module Parlour
 
     sig { params(arr: T::Array[T.untyped]).returns(T.nilable(Symbol)) }
     # Given an array, if all elements in the array are instances of the exact
-    # same class or are otherwise mergeable (for example Namespace and 
+    # same class or are otherwise mergeable (for example Namespace and
     # ClassNamespace), returns the kind of merge which needs to be made. A
     # return value of nil indicates that the values cannot be merged.
     #
     # The following kinds are available:
     #   - They are all the same. (:normal)
-    #   - There are exactly two types, one of which is Namespace and other is a 
+    #   - There are exactly two types, one of which is Namespace and other is a
     #     subclass of it. (:differing_namespaces)
     #   - One of them is Namespace or a subclass (or both, as described above),
-    #     and the only other is Method. (also :differing_namespaces) 
+    #     and the only other is Method. (also :differing_namespaces)
     #
     # @param arr [Array] The array.
     # @return [Symbol] The merge strategy to use, or nil if they can't be
@@ -182,21 +217,13 @@ module Parlour
 
       # Find all the namespaces and non-namespaces
       namespace_types, non_namespace_types = array_types.partition { |x| x <= RbiGenerator::Namespace }
+      exactly_namespace, namespace_subclasses = namespace_types.partition { |x| x == RbiGenerator::Namespace }
+
+      return nil unless namespace_subclasses.empty? \
+        || (namespace_subclasses.length == 1 && namespace_subclasses.first < RbiGenerator::Namespace) \
+        || namespace_subclasses.to_set == Set[RbiGenerator::ClassNamespace, RbiGenerator::StructClassNamespace] \
+        || namespace_subclasses.to_set == Set[RbiGenerator::ClassNamespace, RbiGenerator::EnumClassNamespace]
 
-      # If there are two namespace types, one should be Namespace and the other
-      # should be a subclass of it
-      if namespace_types.length == 2
-        exactly_namespace, exactly_one_subclass = namespace_types.partition { |x| x == RbiGenerator::Namespace }
-
-        return nil unless exactly_namespace.length == 1 \
-          && exactly_one_subclass.length == 1 \
-          && exactly_one_subclass.first < RbiGenerator::Namespace
-      elsif namespace_types.length != 1
-        # The only other valid number of namespaces is 1, where we don't need to
-        # check anything
-        return nil
-      end
-      
       # It's OK, albeit cursed, for there to be a method with the same name as
       # a namespace (Rainbow does this)
       return nil if non_namespace_types.length != 0 && non_namespace_types != [RbiGenerator::Method]
@@ -213,5 +240,26 @@ module Parlour
     def all_eql?(arr)
       arr.each_cons(2).all? { |x, y| x == y }
     end
+
+    sig { params(namespace: RbiGenerator::Namespace, name: T.nilable(String)).void }
+    # Given a namespace and a child name, removes all duplicate children that are mixins
+    # and that have the given name, except the first found instance.
+    #
+    # @param namespace [RbiGenerator::Namespace] The namespace to deduplicate mixins in.
+    # @param name [String] The name of the mixin modules to deduplicate.
+    # @return [void]
+    def deduplicate_mixins_of_name(namespace, name)
+      found_map = {}
+      namespace.children.delete_if do |x|
+        # ignore children whose names don't match
+        next unless x.name == name
+        # ignore children that are not mixins
+        next unless x.is_a?(RbiGenerator::Include) || x.is_a?(RbiGenerator::Extend)
+
+        delete = found_map.key?(x.class)
+        found_map[x.class] = true
+        delete
+      end
+    end
   end
 end

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