parlour 2.0.0 → 5.0.0.beta.1

data/lib/parlour/rbs_generator/extend.rb

@@ -0,0 +1,92 @@
+# typed: true
+module Parlour
+  class RbsGenerator < Generator
+    # Represents an +extend+ call.
+    class Extend < RbsObject
+      sig do
+        params(
+          generator: Generator,
+          type: Types::TypeLike,
+          block: T.nilable(T.proc.params(x: Extend).void)
+        ).void
+      end
+      # Creates a new +extend+ call.
+      #
+      # @param type [Types::TypeLike] The type to extend.
+      def initialize(generator, type:, &block)
+        super(generator, '')
+        @type = type
+        yield_self(&block) if block
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      # Returns true if this instance is equal to another extend.
+      #
+      # @param other [Object] The other instance. If this is not a {Extend} (or a
+      #   subclass of it), this will always return false.
+      # @return [Boolean]
+      def ==(other)
+        Extend === other && type == other.type
+      end
+
+      sig { returns(Types::TypeLike) }
+      # @return [Types::TypeLike] The type to extend.
+      attr_reader :type
+
+      sig do
+        override.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      # Generates the RBS lines for this extend.
+      #
+      # @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, formatted as specified.
+      def generate_rbs(indent_level, options)
+        [options.indented(indent_level, "extend #{String === @type ? @type : @type.generate_rbs}")]
+      end
+
+      sig do
+        override.params(
+          others: T::Array[RbsGenerator::RbsObject]
+        ).returns(T::Boolean)
+      end
+      # Given an array of {Extend} instances, returns true if they may be 
+      # merged into this instance using {merge_into_self}. This is always false.
+      #
+      # @param others [Array<RbsGenerator::RbsObject>] An array of other
+      #   {Extend} 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[RbsGenerator::RbsObject]
+        ).void
+      end
+      # Given an array of {Extend} 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<RbsGenerator::RbsObject>] An array of other
+      #   {Extend} instances.
+      # @return [void]
+      def merge_into_self(others)
+        # We don't need to change anything! We only merge identical extends
+      end
+
+      sig { override.returns(String) }
+      # Returns a human-readable brief string description of this code.
+      #
+      # @return [String]
+      def describe
+        "Extend (#{@type})"
+      end
+    end
+  end
+end

data/lib/parlour/rbs_generator/include.rb

@@ -0,0 +1,92 @@
+# typed: true
+module Parlour
+  class RbsGenerator < Generator
+    # Represents an +include+ call.
+    class Include < RbsObject
+      sig do
+        params(
+          generator: Generator,
+          type: Types::TypeLike,
+          block: T.nilable(T.proc.params(x: Include).void)
+        ).void
+      end
+      # Creates a new +include+ call.
+      #
+      # @param type [Types::TypeLike] The type to include.
+      def initialize(generator, type:, &block)
+        super(generator, '')
+        @type = type
+        yield_self(&block) if block
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      # Returns true if this instance is equal to another include.
+      #
+      # @param other [Object] The other instance. If this is not a {Include} (or a
+      #   subclass of it), this will always return false.
+      # @return [Boolean]
+      def ==(other)
+        Include === other && type == other.type
+      end
+
+      sig { returns(Types::TypeLike) }
+      # @return [Types::TypeLike] The type to include.
+      attr_reader :type
+
+      sig do
+        override.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      # Generates the RBS lines for this include.
+      #
+      # @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, formatted as specified.
+      def generate_rbs(indent_level, options)
+        [options.indented(indent_level, "include #{String === @type ? @type : @type.generate_rbs}")]
+      end
+
+      sig do
+        override.params(
+          others: T::Array[RbsGenerator::RbsObject]
+        ).returns(T::Boolean)
+      end
+      # Given an array of {Include} instances, returns true if they may be 
+      # merged into this instance using {merge_into_self}. This is always false.
+      #
+      # @param others [Array<RbsGenerator::RbsObject>] An array of other
+      #   {Include} 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[RbsGenerator::RbsObject]
+        ).void
+      end
+      # Given an array of {Include} 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<RbsGenerator::RbsObject>] An array of other
+      #   {Include} instances.
+      # @return [void]
+      def merge_into_self(others)
+        # We don't need to change anything! We only merge identical includes
+      end
+
+      sig { override.returns(String) }
+      # Returns a human-readable brief string description of this code.
+      #
+      # @return [String]
+      def describe
+        "Include (#{@type})"
+      end
+    end
+  end
+end

data/lib/parlour/rbs_generator/interface_namespace.rb

@@ -0,0 +1,34 @@
+# typed: true
+module Parlour
+  class RbsGenerator < Generator
+    # Represents an interface definition.
+    class InterfaceNamespace < Namespace
+      extend T::Sig
+
+      sig do
+        override.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      # Generates the RBS lines for this interface.
+      #
+      # @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, formatted as specified.
+      def generate_rbs(indent_level, options)        
+        lines = generate_comments(indent_level, options)
+        lines << options.indented(indent_level, "interface #{name}")
+        lines += generate_body(indent_level + 1, options)
+        lines << options.indented(indent_level, "end")
+      end
+
+      sig { override.returns(String) }
+      # Returns a human-readable brief string description of this interface.
+      # @return [String]
+      def describe
+        "Interface #{name} - #{children.length}"
+      end
+    end
+  end
+end

data/lib/parlour/rbs_generator/method.rb

@@ -0,0 +1,146 @@
+# typed: true
+module Parlour
+  class RbsGenerator < Generator
+    # Represents a method definition.
+    class Method < RbsObject
+      extend T::Sig
+
+      sig do
+        params(
+          generator: Generator,
+          name: String,
+          signatures: T::Array[MethodSignature],
+          class_method: T::Boolean,
+          block: T.nilable(T.proc.params(x: Method).void)
+        ).void
+      end
+      # Creates a new method definition.
+      # @note You should use {Namespace#create_method} rather than this directly.
+      #
+      # @param generator [RbsGenerator] The current RbsGenerator.
+      # @param name [String] The name of this method. You should not specify +self.+ in
+      #   this - use the +class_method+ parameter instead.
+      # @param signatures [Array<MethodSignature>] The signatures for each
+      #   overload of this method.
+      # @param class_method [Boolean] Whether this method is a class method; that is, it
+      #   it is defined using +self.+.
+      # @param block A block which the new instance yields itself to.
+      # @return [void]
+      def initialize(generator, name, signatures, class_method: false, &block)
+        super(generator, name)
+        @signatures = signatures
+        @class_method = class_method
+        yield_self(&block) if block
+      end
+
+      sig { overridable.params(other: Object).returns(T::Boolean).checked(:never) }
+      # Returns true if this instance is equal to another method.
+      #
+      # @param other [Object] The other instance. If this is not a {Method} (or a
+      #   subclass of it), this will always return false.
+      # @return [Boolean]
+      def ==(other)
+        Method === other &&
+          name            == other.name &&
+          signatures      == other.signatures &&
+          class_method    == other.class_method
+      end
+
+      sig { returns(T::Array[MethodSignature]) }
+      # The signatures for each overload of this method.
+      # @return [Array<MethodSignature>]
+      attr_reader :signatures
+
+      sig { returns(T::Boolean) }
+      # Whether this method is a class method; that is, it it is defined using
+      # +self.+.
+      # @return [Boolean]
+      attr_reader :class_method
+
+      sig do
+        override.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      # Generates the RBS lines for this method.
+      #
+      # @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, formatted as specified.
+      def generate_rbs(indent_level, options)
+        definition = "def #{class_method ? 'self.' : ''}#{name}: "
+        lines = generate_comments(indent_level, options)
+
+        # Handle each signature
+        signatures.each.with_index do |sig, i|
+          this_sig_lines = []
+
+          # Start off the first line of the signature, either with the definition
+          # for the first signature, or a pipe for the rest
+          if i == 0
+            this_sig_lines << options.indented(indent_level, definition)
+          else
+            this_sig_lines << options.indented(indent_level, "#{' ' * (definition.length - 2)}| ")
+          end
+
+          # Generate the signature's lines, we'll append them afterwards
+          partial_sig_lines = sig.generate_rbs(options)
+
+          # Merge the first signature line, and indent & concat the rest
+          first_line, *rest_lines = *partial_sig_lines
+          this_sig_lines[0] += first_line
+          rest_lines&.each do |line|
+            this_sig_lines << ' ' * definition.length + options.indented(indent_level, line)
+          end
+
+          # Add on all this signature's lines to the complete lines
+          lines += this_sig_lines
+        end
+
+        lines
+      end
+
+      sig do
+        override.params(
+          others: T::Array[RbsGenerator::RbsObject]
+        ).returns(T::Boolean)
+      end
+      # Given an array of {Method} instances, returns true if they may be merged
+      # into this instance using {merge_into_self}. For instances to be
+      # mergeable, their signatures and definitions must be identical.
+      #
+      # @param others [Array<RbsGenerator::RbsObject>] An array of other {Method} 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[RbsGenerator::RbsObject]
+        ).void
+      end
+      # Given an array of {Method} instances, merges them into this one.
+      # This particular implementation in fact does nothing, because {Method}
+      # instances are only mergeable if they are identical, so nothing needs
+      # to be changed.
+      # You MUST ensure that {mergeable?} is true for those instances.
+      #
+      # @param others [Array<RbsGenerator::RbsObject>] An array of other {Method} instances.
+      # @return [void]
+      def merge_into_self(others)
+        # TODO: merge signatures of different definitions
+      end
+
+      sig { override.returns(String) }
+      # Returns a human-readable brief string description of this method.
+      #
+      # @return [String]
+      def describe
+        # TODO: more info
+        "Method #{name} - #{signatures.length} signatures"
+      end
+    end
+  end
+end

data/lib/parlour/rbs_generator/method_signature.rb

@@ -0,0 +1,104 @@
+# typed: true
+module Parlour
+  class RbsGenerator < Generator
+    # Represents one signature in a method definition.
+    # (This is not an RbsObject because it doesn't generate a full line.)
+    class MethodSignature
+      extend T::Sig
+
+      sig do
+        params(
+          parameters: T::Array[Parameter],
+          return_type: T.nilable(Types::TypeLike),
+          block: T.nilable(Block),
+          type_parameters: T.nilable(T::Array[Symbol])
+        ).void
+      end
+      # Creates a new method signature.
+      #
+      # @param parameters [Array<Parameter>] An array of {Parameter} instances representing this 
+      #   method's parameters.
+      # @param return_type [Types::TypeLike, nil] What this method returns. Passing nil denotes a void return.
+      # @param block [Types::TypeLike, nil] The block this method accepts. Passing nil denotes none.
+      # @param type_parameters [Array<Symbol>, nil] This method's type parameters.
+      # @return [void]
+      def initialize(parameters, return_type = nil, block: nil, type_parameters: nil)
+        @parameters = parameters
+        @return_type = return_type
+        @block = block
+        @type_parameters = type_parameters || []
+      end
+
+      sig { overridable.params(other: Object).returns(T::Boolean).checked(:never) }
+      # Returns true if this instance is equal to another method signature.
+      #
+      # @param other [Object] The other instance. If this is not a {MethodSignature} (or a
+      #   subclass of it), this will always return false.
+      # @return [Boolean]
+      def ==(other)
+        MethodSignature === other &&
+          parameters      == other.parameters &&
+          return_type     == other.return_type &&
+          block           == other.block &&
+          type_parameters == other.type_parameters
+      end
+
+      sig { returns(T::Array[Parameter]) }
+      # An array of {Parameter} instances representing this method's parameters.
+      # @return [Array<Parameter>]
+      attr_reader :parameters
+
+      sig { returns(T.nilable(Types::TypeLike)) }
+      # What this method returns. Passing nil denotes a void return.
+      # @return [Types::TypeLike, nil]
+      attr_reader :return_type
+
+      sig { returns(T.nilable(Block)) }
+      # The block this method accepts.
+      # @return [Block, nil]
+      attr_reader :block
+
+      sig { returns(T::Array[Symbol]) }
+      # This method's type parameters.
+      # @return [Array<Symbol>]
+      attr_reader :type_parameters
+
+      sig { params(options: Options).returns(T::Array[String]) }
+      # Generates the RBS string for this signature.
+      #
+      # @param options [Options] The formatting options to use.
+      # @return [Array<String>] The RBS string, formatted as specified.
+      def generate_rbs(options)
+        block_type = @block&.generate_rbs(options)
+
+        rbs_params = parameters.reject { |x| x.kind == :block }.map(&:to_rbs_param)
+        rbs_return_type = String === @return_type ? @return_type : @return_type&.generate_rbs
+
+        generated_params = parameters.length >= options.break_params \
+          ? ["("] +
+            (
+              parameters.empty? ? [] : rbs_params.map.with_index do |x, i|
+                options.indented(
+                  1,
+                  # Don't include the comma on the last parameter.
+                  parameters.length == i + 1 ? "#{x}" : "#{x},"
+                )
+              end
+            ) +
+            [")"]
+
+          : ["(#{rbs_params.join(', ')})"]
+
+        generated_params[0] = "#{
+          type_parameters.any? ? "[#{type_parameters.join(', ')}] " : '' 
+        }" + T.must(generated_params[0])
+
+        generated_params[-1] = T.must(generated_params[-1]) + "#{
+          (block_type && block_type != 'untyped') ? block_type.first : '' # TODO: doesn't support multi-line block types
+        } -> #{rbs_return_type || 'void'}"
+
+        generated_params
+      end
+    end
+  end
+end