parlour 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74fcc1898cf62ffe8cd5300bb14409c02b9d3a1fd3f323a07606ef399de2f9c7
-  data.tar.gz: 111bb1a4d35a610797e4d845388f6cf7dc2815b8b7732b885bc91eb281fc0408
+  metadata.gz: 9cfa95875716d50b33a4d3557fd6b60d6d477bed3e933c6c369d148399193cff
+  data.tar.gz: 2c9f22571d96d3d592353807c3b40e96e1e567968b761a1ba1174cfeb3a5ecca
 SHA512:
-  metadata.gz: c44c7ca71ffa19834234533348c340c341df6332f8f7ff15708e4d46c4016ef8dd5fbee5012e333338b79746bb8360aef68ea83bf50f651d6fc1b5636567895d
-  data.tar.gz: cc64f14e22f32a6952b896cb51eca120a0a5a94ccbd0aca41147af9d0dcb90d9ba6748771a1a17324a9c7ba5ecf1b6615963a174ce90b5b5a8e2d48ec8de5c91
+  metadata.gz: a40ddab81583e19e1552c1b4e35257a8f99cf8d862221eb4c5b8641097d299a07b0290ab8d6ecedacfc94b0881cd95ab709bf9596446d1e41fceaebd823bc720
+  data.tar.gz: 4de8a3ac91b6c17ebc99d5659f2af8f4cf52083963f60a5851809b05e7237797af6ea81126d35e716b9c46ebe90ace4c0d561d0d582f8ae16a973a159957218a

data/.travis.yml

@@ -1,5 +1,17 @@
 language: ruby
+dist: trusty
 before_install:
   - gem install bundler
+  - gem install yard
 rvm: 
-  - 2.6
+  - 2.6
+after_success:
+  - yard
+deploy:
+  provider: pages
+  local_dir: doc
+  skip_cleanup: true
+  github_token: $GITHUB_TOKEN
+  keep_history: true
+  on:
+    branch: master

data/CHANGELOG.md

@@ -3,6 +3,16 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [0.5.0] - 2019-07-20
+### Added
+- Added the `create_arbitrary` method for inserting arbitrary code into the
+generated RBI file. This is intended for using constructs which Parlour does
+not yet support.
+
+### Changed
+- Breaking change: `add_constant`, `add_include` and `add_extend` have been
+replaced with `create_constant`, `create_include` and `create_extend`.
+
 ## [0.4.0] - 2019-07-10
 ### Changed
 - Breaking change: The Parlour CLI tool no longer takes command-line arguments, and instead uses a `.parlour` configuration file. See the README!

data/README.md

@@ -1,6 +1,7 @@
 # Parlour
 
 [![Build Status](https://travis-ci.org/AaronC81/parlour.svg?branch=master)](https://travis-ci.org/AaronC81/parlour)
+![Gem](https://img.shields.io/gem/v/parlour.svg)
 
 Parlour is an RBI generator and merger for Sorbet. It consists of two key parts:
 
@@ -20,10 +21,11 @@ Parlour is an RBI generator and merger for Sorbet. It consists of two key parts:
     single command and consolidating all of their definitions into a single
     RBI output file.
 
-## Usage
 
-There aren't really any docs currently, so have a look around the code to find
-any extra options you may need.
+Please [**read the wiki**](https://github.com/AaronC81/parlour/wiki) to get
+started!
+
+## Creating RBIs
 
 ### Using just the generator
 
@@ -150,69 +152,6 @@ _Have you written an awesome Parlour plugin? Please submit a PR to add it to thi
 
   - [Sord](https://github.com/AaronC81/sord) - Generate RBIs from YARD documentation
 
-## Parlour's Code Structure
-
-### Overall Flow
-```
-                        STEP 1
-                 All plugins mutate the
-                 instance of RbiGenerator
-                 They generate a tree
-                 structure of RbiObjects
-
-                 +--------+  +--------+
-                 |Plugin 1|  |Plugin 2|
-                 +----+---+  +----+---+         STEP 2
-                      ^           ^        ConflictResolver
-                      |           |        mutates the structure
-+-------------------+ |           |        to fix conflicts
-|                   | |           |
-| One instance of   +-------------+        +----------------+
-| RbiGenerator      +--------------------->+ConflictResolver|
-|                   |                      +----------------+
-+---------+---------+
-          |
-          |
-          |          +-------+          STEP 3
-          +--------->+ File  |    The final RBI is written
-                     +-------+    to a file
-```
-
-### Generation
-Everything that can generate lines of the RBI implements the 
-`RbiGenerator::RbiObject` abstract class. The function `generate_rbi`
-accepts the current indentation level and a set of formatting options.
-(Each object is responsible for generating its own indentation; that is, the
-lines generated by a child object should not then be indented by its parent.)
-
-### Plugins
-Plugins are automatically detected when they subclass `Plugin`. Plugins can then
-be run by passing an array of them, along with an `RbiGenerator`, to
-`Plugin.run_plugins`. Once done, the generator will be populated with a tree of
-(possibly conflicting) `RbiObjects` - the conflict resolver (detailed below)
-will clear up any conflicts.
-  
-### Conflict Resolution
-This is a key part of the plugin/build system. The `ConflictResolver` takes
-a namespace from the `RbiGenerator` and merges duplicate items in it together. 
-This means that many plugins can generate their own signatures which are all 
-bundled into one, conflict-free output RBI.
-
-It is able to do the following merges automatically:
-
-  - If many methods are identical, delete all but one.
-  - If many classes are defined with the same name, merge their methods,
-    includes and extends. (But only if they are all abstract or all not,
-    and only if they don't define more than one superclass together.)
-  - If many modules are defined with the same name, merge their methods,
-    includes and extends. (But only if they are all interfaces or all not.)
-
-If a merge can't be performed automatically, then the `#resolve_conflicts`
-method takes a block. This block is passed all the conflicting objects, and one
-should be selected and returned - all others will be deleted. (Alternatively,
-the block can return nil, and all will be deleted.) This allows the CLI to 
-prompt the user asking them what they'd like to do, in the case of conflicts
-between each plugin's signatures which can't automatically be resolved.
 
 ## Contributing
 

data/lib/parlour.rb

@@ -9,7 +9,11 @@ require 'parlour/rbi_generator/parameter'
 require 'parlour/rbi_generator/rbi_object'
 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'
 require 'parlour/rbi_generator/namespace'
 require 'parlour/rbi_generator/module_namespace'
 require 'parlour/rbi_generator/class_namespace'

data/lib/parlour/rbi_generator/arbitrary.rb

@@ -0,0 +1,92 @@
+# typed: true
+module Parlour
+  class RbiGenerator
+    # Represents miscellaneous Ruby code.
+    class Arbitrary < RbiObject
+      sig do
+        params(
+          generator: RbiGenerator,
+          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)
+      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
+        implementation.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      # Generates the RBI 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 RBI lines, formatted as specified.
+      def generate_rbi(indent_level, options)
+        code.split("\n").map { |l| options.indented(indent_level, l) }
+      end
+
+      sig do
+        implementation.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).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<RbiGenerator::RbiObject>] An array of other
+      #   {Arbitrary} instances.
+      # @return [Boolean] Whether this instance may be merged with them.
+      def mergeable?(others)
+        false
+      end
+
+      sig do 
+        implementation.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).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<RbiGenerator::RbiObject>] 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/rbi_generator/constant.rb

@@ -0,0 +1,94 @@
+# typed: true
+module Parlour
+  class RbiGenerator
+    # Represents a constant definition.
+    class Constant < RbiObject
+      sig do
+        params(
+          generator: RbiGenerator,
+          name: String,
+          value: String,
+          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.
+      def initialize(generator, name: '', value: '', &block)
+        super(generator, name)
+        @value = value
+        yield_self(&block)
+      end
+
+      # @return [String] The value of the constant, as a Ruby code string.
+      sig { returns(String) }
+      attr_reader :value
+
+      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 && value == other.value
+      end
+
+      sig do
+        implementation.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      # Generates the RBI 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 RBI lines, formatted as specified.
+      def generate_rbi(indent_level, options)
+        [options.indented(indent_level, "#{name} = #{value}")]
+      end
+
+      sig do
+        implementation.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).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<RbiGenerator::RbiObject>] 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
+        implementation.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).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<RbiGenerator::RbiObject>] 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 { implementation.returns(String) }
+      # Returns a human-readable brief string description of this code.
+      #
+      # @return [String]
+      def describe
+        "Constant (#{name} = #{value})"
+      end
+    end
+  end
+end

data/lib/parlour/rbi_generator/extend.rb

@@ -0,0 +1,87 @@
+# typed: true
+module Parlour
+  class RbiGenerator
+    # Represents an +extend+ call.
+    class Extend < RbiObject
+      sig do
+        params(
+          generator: RbiGenerator,
+          name: String,
+          block: T.nilable(T.proc.params(x: Extend).void)
+        ).void
+      end
+      # Creates a new +extend+ call.
+      #
+      # @param name [String] The name of the object to be extended.
+      def initialize(generator, name: '', &block)
+        super(generator, name)
+        yield_self(&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 && name == other.name
+      end
+
+      sig do
+        implementation.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      # Generates the RBI 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 RBI lines, formatted as specified.
+      def generate_rbi(indent_level, options)
+        [options.indented(indent_level, "extend #{name}")]
+      end
+
+      sig do
+        implementation.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).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<RbiGenerator::RbiObject>] 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 
+        implementation.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).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<RbiGenerator::RbiObject>] 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 { implementation.returns(String) }
+      # Returns a human-readable brief string description of this code.
+      #
+      # @return [String]
+      def describe
+        "Extend (#{name})"
+      end
+    end
+  end
+end

data/lib/parlour/rbi_generator/include.rb

@@ -0,0 +1,87 @@
+# typed: true
+module Parlour
+  class RbiGenerator
+    # Represents an +include+ call.
+    class Include < RbiObject
+      sig do
+        params(
+          generator: RbiGenerator,
+          name: String,
+          block: T.nilable(T.proc.params(x: Include).void)
+        ).void
+      end
+      # Creates a new +include+ call.
+      #
+      # @param name [String] The name of the object to be included.
+      def initialize(generator, name: '', &block)
+        super(generator, name)
+        yield_self(&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 && name == other.name
+      end
+
+      sig do
+        implementation.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      # Generates the RBI 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 RBI lines, formatted as specified.
+      def generate_rbi(indent_level, options)
+        [options.indented(indent_level, "include #{name}")]
+      end
+
+      sig do
+        implementation.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).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<RbiGenerator::RbiObject>] 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 
+        implementation.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).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<RbiGenerator::RbiObject>] 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 { implementation.returns(String) }
+      # Returns a human-readable brief string description of this code.
+      #
+      # @return [String]
+      def describe
+        "Include (#{name})"
+      end
+    end
+  end
+end

data/lib/parlour/rbi_generator/namespace.rb

@@ -18,7 +18,7 @@ module Parlour
       # @param options [Options] The formatting options to use.
       # @return [Array<String>] The RBI lines, formatted as specified.
       def generate_rbi(indent_level, options)
-        generate_comments(indent_level, options) +  
+        generate_comments(indent_level, options) +
           generate_body(indent_level, options)
       end
 
@@ -40,9 +40,6 @@ module Parlour
       def initialize(generator, name = nil, &block)
         super(generator, name || '<anonymous namespace>')
         @children = []
-        @extends = []
-        @includes = []
-        @constants = []
         @next_comments = []
         yield_self(&block)
       end
@@ -52,23 +49,35 @@ module Parlour
       # @return [Array<RbiObject>]
       attr_reader :children
 
-      sig { returns(T::Array[String]) }
-      # A list of strings which are each used in an +extend+ statement in this
-      # namespace.
-      # @return [Array<String>]
-      attr_reader :extends
+      sig { returns(T::Array[RbiGenerator::Extend]) }
+      # The {RbiGenerator::Extend} objects from {children}.
+      # @return [Array<RbiGenerator::Extend>]
+      def extends
+        T.cast(
+          children.select { |c| c.is_a?(RbiGenerator::Extend) },
+          T::Array[RbiGenerator::Extend]
+        )
+      end
 
-      sig { returns(T::Array[String]) }
-      # A list of strings which are each used in an +include+ statement in this
-      # namespace.
-      # @return [Array<String>]
-      attr_reader :includes
+      sig { returns(T::Array[RbiGenerator::Include]) }
+      # The {RbiGenerator::Include} objects from {children}.
+      # @return [Array<RbiGenerator::Include>]
+      def includes
+        T.cast(
+          children.select { |c| c.is_a?(RbiGenerator::Include) },
+          T::Array[RbiGenerator::Include]
+        )
+      end
 
-      sig { returns(T::Array[[String, String]]) }
-      # A list of constants which are defined in this namespace, in the form of
-      # pairs [name, value].
-      # @return [Array<(String, String)>]
-      attr_reader :constants
+      sig { returns(T::Array[RbiGenerator::Constant]) }
+      # The {RbiGenerator::Constant} objects from {children}.
+      # @return [Array<RbiGenerator::Constant>]
+      def constants
+        T.cast(
+          children.select { |c| c.is_a?(RbiGenerator::Constant) },
+          T::Array[RbiGenerator::Constant]
+        )
+      end
 
       sig { params(comment: T.any(String, T::Array[String])).void }
       # Adds one or more comments to the next child RBI object to be created.
@@ -282,41 +291,90 @@ module Parlour
         create_attribute(name: name, kind: :accessor, type: type, &block)
       end
 
-      sig { params(name: String).void }
+      # Creates a new arbitrary code section.
+      # You should rarely have to use this!
+      #
+      # @param code [String] The code to insert.
+      # @param block A block which the new instance yields itself to.
+      # @return [RbiGenerator::Arbitrary]
+      def create_arbitrary(code: nil, &block)
+        code = T.must(code)
+        new_arbitrary = RbiGenerator::Arbitrary.new(
+          generator,
+          code: code,
+          &block
+        )
+        move_next_comments(new_arbitrary)
+        children << new_arbitrary
+        new_arbitrary
+      end
+
+      sig { params(name: String, block: T.nilable(T.proc.params(x: Extend).void)).returns(RbiGenerator::Extend) }
       # Adds a new +extend+ to this namespace.
       #
       # @example Add an +extend+ to a class.
-      #   class.add_extend('ExtendableClass') #=> extend ExtendableClass
+      #   class.create_extend(name: 'ExtendableClass') #=> extend ExtendableClass
       #
-      # @param name [String] A code string for what is extended, for example
+      # @param object [String] A code string for what is extended, for example
       #   +"MyModule"+.
-      # @return [void]
-      def add_extend(name)
-        extends << name
+      # @param block A block which the new instance yields itself to.
+      # @return [RbiGenerator::Extend]
+      def create_extend(name: nil, &block)
+        name = T.must(name)
+        new_extend = RbiGenerator::Extend.new(
+          generator,
+          name: name,
+          &block
+        )
+        move_next_comments(new_extend)
+        children << new_extend
+        new_extend
       end
 
-      sig { params(name: String).void }
+      sig { params(name: String, block: T.nilable(T.proc.params(x: Include).void)).returns(Include) }
       # Adds a new +include+ to this namespace.
       #
       # @example Add an +include+ to a class.
-      #   class.add_include('IncludableClass') #=> include IncludableClass
+      #   class.create_include(name:  'IncludableClass') #=> include IncludableClass
       #
-      # @param name [String] A code string for what is included, for example
+      # @param object [String] A code string for what is included, for example
       #   +"Enumerable"+.
-      # @return [void]
-      def add_include(name)
-        includes << name
+      # @param block A block which the new instance yields itself to.
+      # @return [RbiGenerator::Include]
+      def create_include(name: nil, &block)
+        name = T.must(name)
+        new_include = RbiGenerator::Include.new(
+          generator,
+          name: name,
+          &block
+        )
+        move_next_comments(new_include)
+        children << new_include
+        new_include
       end
 
-      sig { params(name: String, value: String).void }
+      sig { params(name: String, value: String, block: T.nilable(T.proc.params(x: Constant).void)).returns(Constant) }
       # Adds a new constant definition to this namespace.
       #
+      # @example Add an +Elem+ constant to the class.
+      #   class.create_include(name: 'IncludableClass') #=> Elem = String
+      #
       # @param name [String] The name of the constant.
-      # @param value [String] A Ruby code string for this constant's value, for
-      #   example +"3.14"+ or +"T.type_alias(X)"+
-      # @return [void]
-      def add_constant(name, value)
-        constants << [name, value]
+      # @param value [String] The value of the constant, as a Ruby code string.
+      # @param block A block which the new instance yields itself to.
+      # @return [RbiGenerator::Constant]
+      def create_constant(name: nil, value: nil, &block)
+        name = T.must(name)
+        value = T.must(value)
+        new_constant = RbiGenerator::Constant.new(
+          generator,
+          name: name,
+          value: value,
+          &block
+        )
+        move_next_comments(new_constant)
+        children << new_constant
+        new_constant
       end
 
       sig do
@@ -352,9 +410,6 @@ module Parlour
           other = T.cast(other, Namespace)
 
           other.children.each { |c| children << c }
-          other.extends.each { |e| extends << e }
-          other.includes.each { |i| includes << i }
-          other.constants.each { |i| constants << i }
         end
       end
 
@@ -385,20 +440,22 @@ module Parlour
         result = []
 
         if includes.any? || extends.any? || constants.any?
-          result += includes.map do |i|
-            options.indented(indent_level, "include #{i}")
-          end
-          result += extends.map do |e|
-            options.indented(indent_level, "extend #{e}")
-          end
-          result += constants.map do |c|
-            name, value = c
-            options.indented(indent_level, "#{name} = #{value}")
-          end
+          result += includes
+            .flat_map { |x| x.generate_rbi(indent_level, options) }
+            .reject { |x| x.strip == '' }
+          result += extends
+            .flat_map { |x| x.generate_rbi(indent_level, options) }
+            .reject { |x| x.strip == '' }
+          result += constants
+            .flat_map { |x| x.generate_rbi(indent_level, options) }
+            .reject { |x| x.strip == '' }
           result << ""
         end
 
-        first, *rest = children
+        first, *rest = children.reject do |child|
+          # We already processed these kinds of children
+          child.is_a?(Include) || child.is_a?(Extend) || child.is_a?(Constant)
+        end
         unless first
           # Remove any trailing whitespace due to includes
           result.pop if result.last == ''

data/lib/parlour/version.rb

@@ -1,5 +1,5 @@
 # typed: strong
 module Parlour
   # The library version.
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parlour
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Aaron Christiansen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-07-10 00:00:00.000000000 Z
+date: 2019-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -132,8 +132,12 @@ files:
 - lib/parlour/conflict_resolver.rb
 - lib/parlour/plugin.rb
 - lib/parlour/rbi_generator.rb
+- lib/parlour/rbi_generator/arbitrary.rb
 - lib/parlour/rbi_generator/attribute.rb
 - lib/parlour/rbi_generator/class_namespace.rb
+- lib/parlour/rbi_generator/constant.rb
+- lib/parlour/rbi_generator/extend.rb
+- lib/parlour/rbi_generator/include.rb
 - lib/parlour/rbi_generator/method.rb
 - lib/parlour/rbi_generator/module_namespace.rb
 - lib/parlour/rbi_generator/namespace.rb