parlour 4.0.0 → 5.0.0.beta.4

data/lib/parlour/rbs_generator.rb

@@ -0,0 +1,24 @@
+# typed: true
+module Parlour
+  # The RBS generator.
+  class RbsGenerator < Generator  
+    def initialize(**hash)
+      super
+      @root = RbsGenerator::Namespace.new(self)
+    end
+
+    sig { overridable.returns(RbsGenerator::Namespace) }
+    # The root {Namespace} of this generator.
+    # @return [Namespace]
+    attr_reader :root
+    
+    sig { overridable.returns(String) }
+    # Returns the complete contents of the generated RBS file as a string.
+    #
+    # @return [String] The generated RBS file
+    def rbs
+      root.generate_rbs(0, options).join("\n")
+    end
+  end
+  end
+  

data/lib/parlour/rbs_generator/arbitrary.rb

@@ -0,0 +1,92 @@
+# typed: true
+module Parlour
+  class RbsGenerator < Generator
+    # Represents miscellaneous Ruby code.
+    class Arbitrary < RbsObject
+      sig do
+        params(
+          generator: Generator,
+          code: String,
+          block: T.nilable(T.proc.params(x: Arbitrary).void)
+        ).void
+      end
+      # Creates new arbitrary code.
+      #
+      # @param code [String] The arbitrary code string. Indentation is added to
+      #   the beginning of each line.
+      def initialize(generator, code: '', &block)
+        super(generator, '')
+        @code = code
+        yield_self(&block) if block
+      end
+
+      sig { returns(String) }
+      # Returns arbitrary code string.
+      attr_accessor :code
+
+      sig { params(other: Object).returns(T::Boolean) }
+      # Returns true if this instance is equal to another arbitrary code line.
+      #
+      # @param other [Object] The other instance. If this is not a {Arbitrary} (or a
+      #   subclass of it), this will always return false.
+      # @return [Boolean]
+      def ==(other)
+        Arbitrary === other && code == other.code
+      end
+
+      sig do
+        override.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      # Generates the RBS lines for this arbitrary code.
+      #
+      # @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)
+        code.split("\n").map { |l| options.indented(indent_level, l) }
+      end
+
+      sig do
+        override.params(
+          others: T::Array[RbsGenerator::RbsObject]
+        ).returns(T::Boolean)
+      end
+      # Given an array of {Arbitrary} 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
+      #   {Arbitrary} instances.
+      # @return [Boolean] Whether this instance may be merged with them.
+      def mergeable?(others)
+        false
+      end
+
+      sig do 
+        override.params(
+          others: T::Array[RbsGenerator::RbsObject]
+        ).void
+      end
+      # Given an array of {Arbitrary} instances, merges them into this one.
+      # This particular implementation always throws an exception, because
+      # {mergeable?} is always false.
+      #
+      # @param others [Array<RbsGenerator::RbsObject>] An array of other
+      #   {Arbitrary} instances.
+      # @return [void]
+      def merge_into_self(others)
+        raise 'arbitrary code is never mergeable'
+      end
+
+      sig { override.returns(String) }
+      # Returns a human-readable brief string description of this code.
+      #
+      # @return [String]
+      def describe
+        "Arbitrary code (#{code})"
+      end
+    end
+  end
+end

data/lib/parlour/rbs_generator/attribute.rb

@@ -0,0 +1,82 @@
+# typed: true
+module Parlour
+  class RbsGenerator < Generator
+    # Represents an attribute reader, writer or accessor.
+    class Attribute < RbsGenerator::Method
+      extend T::Sig
+
+      sig do
+        params(
+          generator: Generator,
+          name: String,
+          kind: Symbol,
+          type: Types::TypeLike,
+          block: T.nilable(T.proc.params(x: Attribute).void)
+        ).void
+      end
+      # Creates a new attribute.
+      # @note You should use {Namespace#create_attribute} rather than this directly.
+      #
+      # @param generator [RbsGenerator] The current RbsGenerator.
+      # @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, Types::Type] This attribute's type.
+      # @param block A block which the new instance yields itself to.
+      # @return [void]
+      def initialize(generator, name, kind, type, &block)
+        @type = type
+        @kind = kind
+        case kind
+        when :accessor, :reader
+          super(generator, name, [MethodSignature.new([], type)], &block)
+        when :writer
+          super(generator, name, [MethodSignature.new([
+            Parameter.new(name, type: type)
+          ], type)], &block)
+        else
+          raise 'unknown kind'
+        end
+      end
+
+      sig { returns(Symbol) }
+      # The kind of attribute this is; one of +:writer+, +:reader+, or +:accessor+.
+      # @return [Symbol]
+      attr_reader :kind
+
+      sig { returns(Types::TypeLike) }
+      # The type of this attribute.
+      attr_reader :type
+
+      sig do
+        override.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      # Generates the RBS lines for this arbstrary code.
+      #
+      # @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)
+        generate_comments(indent_level, options) + [options.indented(
+          indent_level,
+          "attr_#{kind} #{name}: #{String === @type ? @type : @type.generate_rbs}"
+        )]
+      end
+
+      sig { override.params(other: Object).returns(T::Boolean) }
+      # Returns true if this instance is equal to another attribute.
+      #
+      # @param other [Object] The other instance. If this is not a {Attribute}
+      #   (or a subclass of it), this will always return false.
+      # @return [Boolean]
+      def ==(other)
+        T.must(
+          super(other) && Attribute === other && kind == other.kind
+        )
+      end
+    end
+  end
+end

data/lib/parlour/rbs_generator/block.rb

@@ -0,0 +1,49 @@
+# typed: true
+module Parlour
+  class RbsGenerator < Generator
+    # Represents a block in a method signature.
+    # (This is not an RbsObject because it doesn't generate a full line.)
+    class Block
+      extend T::Sig
+
+      sig { params(type: Types::Proc, required: T::Boolean).void }
+      # Creates a new block for a method signature.
+      #
+      # @param type [Types::Proc] The type of this block.
+      # @param required [T::Boolean] Whether this block is required.
+      def initialize(type, required)
+        @type = type
+        @required = required
+      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)
+        Block === other && type == other.type && required == other.required
+      end
+
+      sig { returns(Types::Proc) }
+      # The type of this block.
+      # @return [Types::Proc]
+      attr_reader :type
+
+      sig { returns(T::Boolean) }
+      # Whether this block is required.
+      # @return [Boolean]
+      attr_reader :required
+
+      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)
+        ["#{required ? '' : '?'}{ #{type.generate_rbs} }"]
+      end
+    end
+  end
+end

data/lib/parlour/rbs_generator/class_namespace.rb

@@ -0,0 +1,106 @@
+# typed: true
+module Parlour
+  class RbsGenerator < Generator
+    # Represents a class definition.
+    class ClassNamespace < Namespace
+      extend T::Sig
+
+      sig do
+        params(
+          generator: Generator,
+          name: String,
+          superclass: T.nilable(Types::TypeLike),
+          block: T.nilable(T.proc.params(x: ClassNamespace).void)
+        ).void
+      end
+      # Creates a new class definition.
+      # @note You should use {Namespace#create_class} rather than this directly.
+      #
+      # @param generator [RbsGenerator] The current RbsGenerator.
+      # @param name [String] The name of this class.
+      # @param final [Boolean] Whether this namespace is final.
+      # @param superclass [String, nil] The superclass of this class, or nil if it doesn't
+      #   have one.
+      # @param abstract [Boolean] A boolean indicating whether this class is abstract.
+      # @param block A block which the new instance yields itself to.
+      # @return [void]
+      def initialize(generator, name, superclass, &block)
+        super(generator, name, &block)
+        @superclass = superclass
+      end
+
+      sig do
+        override.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      def generate_rbs(indent_level, options)
+        class_definition = @superclass.nil? \
+          ? "class #{name}"
+          : "class #{name} < #{String === @superclass ? @superclass : @superclass.generate_rbs}"
+      
+        lines = generate_comments(indent_level, options)
+        lines << options.indented(indent_level, class_definition)
+        lines += generate_body(indent_level + 1, options)
+        lines << options.indented(indent_level, "end")
+      end
+
+      sig { returns(T.nilable(Types::TypeLike)) }
+      # The superclass of this class, or nil if it doesn't have one.
+      # @return [Types::TypeLike, nil]
+      attr_reader :superclass
+
+      sig do
+        override.params(
+          others: T::Array[RbsGenerator::RbsObject]
+        ).returns(T::Boolean)
+      end
+      # Given an array of {Namespace} instances, returns true if they may
+      # be merged into this instance using {merge_into_self}. For instances to
+      # be mergeable, they must either all be abstract or all not be abstract,
+      # and they must define the same superclass (or none at all).
+      #
+      # @param others [Array<RbsGenerator::RbsObject>] An array of other {Namespace} instances.
+      # @return [Boolean] Whether this instance may be merged with them.
+      def mergeable?(others)
+        others = T.cast(others, T::Array[Namespace]) rescue (return false)
+        all = others + [self]
+
+        all_classes = T.cast(all.select { |x| ClassNamespace === x }, T::Array[ClassNamespace])
+
+        all_classes.map(&:superclass).compact.uniq.length <= 1
+      end
+
+      sig do 
+        override.params(
+          others: T::Array[RbsGenerator::RbsObject]
+        ).void
+      end
+      # Given an array of {ClassNamespace} instances, merges them into this one.
+      # You MUST ensure that {mergeable?} is true for those instances.
+      # 
+      # @param others [Array<RbsGenerator::RbsObject>] An array of other {ClassNamespace} instances.
+      # @return [void]
+      def merge_into_self(others)
+        super
+
+        others.each do |other|
+          next unless ClassNamespace === other
+          other = T.cast(other, ClassNamespace)
+
+          @superclass = other.superclass unless superclass
+        end
+      end
+
+      sig { override.returns(String) }
+      # Returns a human-readable brief string description of this class.
+      # @return [String]
+      def describe
+        "Class #{name} - #{"superclass #{superclass}, " if superclass}" +
+          "#{children.length} children, " +
+          "#{includes.length} includes, #{extends.length} extends"
+      end
+    end
+  end
+end

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