parlour 3.0.0 → 5.0.0.beta.3

data/lib/parlour/rbs_generator/constant.rb

@@ -0,0 +1,95 @@
+# typed: true
+module Parlour
+  class RbsGenerator < Generator
+    # Represents a constant definition.
+    class Constant < RbsObject
+      sig do
+        params(
+          generator: Generator,
+          name: String,
+          type: Types::TypeLike,
+          block: T.nilable(T.proc.params(x: Constant).void)
+        ).void
+      end
+      # Creates a new constant definition.
+      #
+      # @param name [String] The name of the constant.
+      # @param value [String] The value of the constant, as a Ruby code string.
+      #   eigenclass of the current namespace.
+      def initialize(generator, name, type:, &block)
+        super(generator, name)
+        @type = type
+        yield_self(&block) if block
+      end
+
+      # @return [Types::TypeLike] The type of the constant.
+      sig { returns(Types::TypeLike) }
+      attr_reader :type
+
+      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)
+        Constant === other && name == other.name && type == other.type
+      end
+
+      sig do
+        override.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      # Generates the RBS lines for this constant.
+      #
+      # @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, "#{name}: #{String === @type ? @type : @type.generate_rbs}")]
+      end
+
+      sig do
+        override.params(
+          others: T::Array[RbsGenerator::RbsObject]
+        ).returns(T::Boolean)
+      end
+      # Given an array of {Constant} 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
+      #   {Constant} 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 {Constant} 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 constants
+      end
+
+      sig { override.returns(String) }
+      # Returns a human-readable brief string description of this code.
+      #
+      # @return [String]
+      def describe
+        "Constant (#{name} = #{type})"
+      end
+    end
+  end
+end

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