parlour 5.0.0.beta.3 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c9fa581e9b41195e54a4716df7926d1beb225c47871ff39d2f08fb0fa462aeb
-  data.tar.gz: 1aa333b0896df783baefa79d87fdbda732dea8676b85e89b7d76de607716658c
+  metadata.gz: 1fd931ae39df4abe6c2080d7730f5ae9761f934e31632f0bade970a08f40e291
+  data.tar.gz: b1c626e9baef6177c35e0512807f08dd7d80bca7ffb0730529fdc8c4bd8923c3
 SHA512:
-  metadata.gz: 30486957baea0d7b30f827483ca69fbf589bd55039bedbcee6ea4f6258c0601612d191818a547569b32fe2e805dd29e34f27a46005eb3d5586dd7cb3462f7fb2
-  data.tar.gz: ed021b13ea01c171852be2d4892ba1042bc7dbf747e3413881e7d9c674553dea82337172c986dfec8ec78bfbed2be5519b6a091e2f3cd19f142797f54e35689e
+  metadata.gz: dafd27bee77f5cf8c86c1057b19a4ef3d62abcfd21ea79c8f914629cb857216345ec70cfe5919a1897c98426e30d180b06d5610a1295e190a81d5405cf648b44
+  data.tar.gz: b825ea72df23f2bf0e3e5aa406f1e5f5e9890ec52ddba815e3bebcafda52edc6f85590827f7d097fdb1897b57ef4b9ad4b0adec387e02525977a8d22d391467a

data/.github/workflows/ruby.yml

@@ -0,0 +1,46 @@
+name: Run tests
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        ruby: [2.4, 2.5, 2.6, 2.7, 3.0]
+    continue-on-error: false
+      
+    runs-on: ubuntu-latest    
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: Install dependencies
+      run: bundle install
+    - name: Run tests
+      run: bundle exec rake
+    - name: Check RBI is up-to-date
+      run: ./ci/check_rbi.sh
+
+  # Deploy documentation to GitHub Pages, if this is a push to master and the tests passed
+  deploy-docs:
+    if: ${{ github.ref == 'refs/heads/master' }}
+    
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 2.7
+    - name: Install dependencies
+      run: bundle install
+    - name: Build documentation
+      run: bundle exec yard
+    - name: Deploy to GitHub Actions
+      uses: JamesIves/github-pages-deploy-action@3.7.1
+      with:
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+        branch: gh-pages
+        folder: doc

data/CHANGELOG.md

@@ -3,29 +3,23 @@ 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/).
 
-## [5.0.0.beta.3] - 2020-09-15
+## [6.0.0] - 2021-02-28
 ### Changed
-- Changed the RBS keyword warning to come from "RBS generation" rather than
-  "Type generalization"
-- Added many more of RBS' keywords which are detected and prefixed with an
-  underscore to avoid syntax errors
-
-## [5.0.0.beta.2] - 2020-09-14
-### Added
-- Added `Types::Type#describe` for simple text descriptions of types
-- Added `Types::Self` for RBI's `T.self_type` or RBS' `self`
-
-### Fixed
-- Fixed `RbiGenerator::Namespace#create_method`'s `returns:` kwarg only
-  accepting String types
-- Fixed lack of spacing between argument lists and blocks in RBS
-- Fixed RBS attributes not having comments
-
-## [5.0.0.beta.1] - 2020-09-13
+- The RBI previously included with the Parlour gem has been removed,
+  as it was causing issues with Sorbet. **If you were relying on Parlour's
+  bundled RBI while type-checking your project, you will now need to use the
+  RBI from sorbet-typed or the Parlour repo.**
+- `Namespace#path` will now work much more reliably for classes and
+  modules which replace methods from `Module` and `Class`, such as
+  `#name`.
+
+## [5.0.0] - 2020-12-26
 ### Added
 - Added RBS generation support! This includes:
   - The new `RbsGenerator` class
   - `RbsObject` and a set of subclasses representing different RBS components
+  - **Note:** RBS does not yet support Parlour plugins and some other features.
+    Refer to the README for a full breakdown!
 - Added the `Types` module, which is used to describe types agnostic of the
   underlying type system
   - Added `RbiGenerator::Namespace#generalize_from_rbi!` to convert RBI string
@@ -37,6 +31,66 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   - `TypedObject`, which `RbiObject` and `RbsObject` both inherit from
   - `Generator`, which `RbiGenerator` and `RbsGenerator` both inherit from
 - Added RBI type aliases
+- Added `sealed!` for RBI namespaces
+- Added `abstract!` for RBI modules
+
+### Changed
+- `Parlour::RbiGenerator::Options` is now `Parlour::Options`. An alias exists
+  for now, but **`Parlour::RbiGenerator::Options` is deprecated** and could be
+  removed in future versions.
+- Updated README and gem metadata to refer to Parlour as a type information
+  generator, rather than just an RBI generator
+
+<details>
+  <summary>5.0.0 pre-releases</summary>
+  
+  ## [5.0.0.beta.6] - 2020-10-04
+  ### Fixed
+  - Fixed collection types sometimes generating as `T::::Array`
+
+  ## [5.0.0.beta.5] - 2020-10-03
+  ### Added
+  - Added `Types::Generic` for user-defined generic types
+
+  ## [5.0.0.beta.4] - 2020-09-22
+  ### Added
+  - Added support for parsing type aliases from RBI
+  - Added conversion from RBI to RBS type aliases
+
+  ## [5.0.0.beta.3] - 2020-09-15
+  ### Changed
+  - Changed the RBS keyword warning to come from "RBS generation" rather than
+    "Type generalization"
+  - Added many more of RBS' keywords which are detected and prefixed with an
+    underscore to avoid syntax errors
+
+  ## [5.0.0.beta.2] - 2020-09-14
+  ### Added
+  - Added `Types::Type#describe` for simple text descriptions of types
+  - Added `Types::Self` for RBI's `T.self_type` or RBS' `self`
+
+  ### Fixed
+  - Fixed `RbiGenerator::Namespace#create_method`'s `returns:` kwarg only
+    accepting String types
+  - Fixed lack of spacing between argument lists and blocks in RBS
+  - Fixed RBS attributes not having comments
+
+  ## [5.0.0.beta.1] - 2020-09-13
+  ### Added
+  - Added RBS generation support! This includes:
+    - The new `RbsGenerator` class
+    - `RbsObject` and a set of subclasses representing different RBS components
+  - Added the `Types` module, which is used to describe types agnostic of the
+    underlying type system
+    - Added `RbiGenerator::Namespace#generalize_from_rbi!` to convert RBI string
+      types into `Types` types
+    - **Specifying types as strings is still currently supported, but may be
+      phased out in future, and should be avoided in new projects**.
+  - Added conversion from RBI to RBS type trees
+  - Added a couple of classes to deduplicate functionality between type systems:
+    - `TypedObject`, which `RbiObject` and `RbsObject` both inherit from
+    - `Generator`, which `RbiGenerator` and `RbsGenerator` both inherit from
+  - Added RBI type aliases
 
 ### Changed
 - `Parlour::RbiGenerator::Options` is now `Parlour::Options`. An alias exists
@@ -44,6 +98,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   removed in future versions.
 - Updated README and gem metadata to refer to Parlour as a type information
   generator, rather than just an RBI generator
+</details>
 
 ## [4.0.1] - 2020-08-05
 ### Fixed

data/README.md

@@ -407,6 +407,8 @@ srb rbi gems
 srb rbi sorbet-typed
 ```
 
+You should also regenerate the parlour.rbi file by running `bundle exec parlour`. Don't edit this file manually, as your changes will be overwritten!
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/ci/check_rbi.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+# Checks that the RBI in rbi/parlour.rbi is up-to-date with committed changes.
+# This is done by generating a new RBI and comparing it with the committed RBI.
+set -ev
+
+bundle install
+mv rbi/parlour.rbi rbi/parlour-committed.rbi
+bundle exec parlour
+cmp -s rbi/parlour.rbi rbi/parlour-committed.rbi

data/lib/parlour/conversion/rbi_to_rbs.rb

@@ -121,6 +121,12 @@ module Parlour
             type: node.value,
           ).add_comments(node.comments)
 
+        when RbiGenerator::TypeAlias
+          new_parent.create_type_alias(
+            node.name,
+            type: node.type,
+          ).add_comments(node.comments)
+
         when RbiGenerator::Extend
           new_parent.create_extend(node.name).add_comments(node.comments)
 

data/lib/parlour/rbi_generator/class_namespace.rb

@@ -10,6 +10,7 @@ module Parlour
           generator: Generator,
           name: String,
           final: T::Boolean,
+          sealed: T::Boolean,
           superclass: T.nilable(String),
           abstract: T::Boolean,
           block: T.nilable(T.proc.params(x: ClassNamespace).void)
@@ -21,13 +22,14 @@ module Parlour
       # @param generator [RbiGenerator] The current RbiGenerator.
       # @param name [String] The name of this class.
       # @param final [Boolean] Whether this namespace is final.
+      # @param sealed [Boolean] Whether this namespace is sealed.
       # @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, final, superclass, abstract, &block)
-        super(generator, name, final, &block)
+      def initialize(generator, name, final, sealed, superclass, abstract, &block)
+        super(generator, name, final, sealed, &block)
         @superclass = superclass
         @abstract = abstract
       end

data/lib/parlour/rbi_generator/enum_class_namespace.rb

@@ -10,6 +10,7 @@ module Parlour
           generator: Generator,
           name: String,
           final: T::Boolean,
+          sealed: T::Boolean,
           enums: T::Array[T.any([String, String], String)],
           abstract: T::Boolean,
           block: T.nilable(T.proc.params(x: EnumClassNamespace).void)
@@ -21,12 +22,13 @@ module Parlour
       # @param generator [RbiGenerator] The current RbiGenerator.
       # @param name [String] The name of this class.
       # @param final [Boolean] Whether this namespace is final.
+      # @param sealed [Boolean] Whether this namespace is sealed.
       # @param enums [Array<(String, String), String>] The values of the enumeration.
       # @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, final, enums, abstract, &block)
-        super(generator, name, final, 'T::Enum', abstract, &block)
+      def initialize(generator, name, final, sealed, enums, abstract, &block)
+        super(generator, name, final, sealed, 'T::Enum', abstract, &block)
         @enums = enums
       end
 

data/lib/parlour/rbi_generator/module_namespace.rb

@@ -10,24 +10,29 @@ module Parlour
           generator: Generator,
           name: String,
           final: T::Boolean,
+          sealed: T::Boolean,
           interface: T::Boolean,
+          abstract: T::Boolean,
           block: T.nilable(T.proc.params(x: ClassNamespace).void)
         ).void
       end
       # Creates a new module definition.
       # @note You should use {Namespace#create_module} rather than this directly.
-      # 
+      #
       # @param generator [RbiGenerator] The current RbiGenerator.
       # @param name [String] The name of this module.
       # @param final [Boolean] Whether this namespace is final.
+      # @param sealed [Boolean] Whether this namespace is sealed.
       # @param interface [Boolean] A boolean indicating whether this module is an
       #   interface.
+      # @param abstract [Boolean] A boolean indicating whether this module is abstract.
       # @param block A block which the new instance yields itself to.
       # @return [void]
-      def initialize(generator, name, final, interface, &block)
-        super(generator, name, final, &block)
+      def initialize(generator, name, final, sealed, interface, abstract, &block)
+        super(generator, name, final, sealed, &block)
         @name = name
         @interface = interface
+        @abstract = abstract
       end
 
       sig do
@@ -41,10 +46,11 @@ module Parlour
       # @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)        
+      def generate_rbi(indent_level, options)
         lines = generate_comments(indent_level, options)
         lines << options.indented(indent_level, "module #{name}")
         lines += [options.indented(indent_level + 1, "interface!"), ""] if interface
+        lines += [options.indented(indent_level + 1, "abstract!"), ""] if abstract
         lines += generate_body(indent_level + 1, options)
         lines << options.indented(indent_level, "end")
       end
@@ -54,6 +60,11 @@ module Parlour
       # @return [Boolean]
       attr_reader :interface
 
+      sig { returns(T::Boolean) }
+      # A boolean indicating whether this module is abstract or not.
+      # @return [Boolean]
+      attr_reader :abstract
+
       sig do
         override.params(
           others: T::Array[RbiGenerator::RbiObject]
@@ -61,7 +72,7 @@ module Parlour
       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 interfaces or all not be 
+      # be mergeable, they must either all be interfaces or all not be
       # interfaces.
       #
       # @param others [Array<RbiGenerator::RbiObject>] An array of other {Namespace} instances.
@@ -75,7 +86,7 @@ module Parlour
         all_modules.map(&:interface).uniq.length == 1
       end
 
-      sig do 
+      sig do
         override.params(
           others: T::Array[RbiGenerator::RbiObject]
         ).void
@@ -93,7 +104,8 @@ module Parlour
       # Returns a human-readable brief string description of this module.
       # @return [String]
       def describe
-        "Module #{name} - #{"interface, " if interface}#{children.length} " +
+        "Module #{name} - #{"interface, " if interface}" +
+          "#{"abstract, " if abstract}#{children.length} " +
           "children, #{includes.length} includes, #{extends.length} extends"
       end
 

data/lib/parlour/rbi_generator/namespace.rb

@@ -27,6 +27,7 @@ module Parlour
           generator: Generator,
           name: T.nilable(String),
           final: T::Boolean,
+          sealed: T::Boolean,
           block: T.nilable(T.proc.params(x: Namespace).void)
         ).void
       end
@@ -37,13 +38,15 @@ module Parlour
       # @param generator [RbiGenerator] The current RbiGenerator.
       # @param name [String, nil] The name of this module.
       # @param final [Boolean] Whether this namespace is final.
+      # @param final [Boolean] Whether this namespace is sealed.
       # @param block A block which the new instance yields itself to.
       # @return [void]
-      def initialize(generator, name = nil, final = false, &block)
+      def initialize(generator, name = nil, final = false, sealed = false, &block)
         super(generator, name || '<anonymous namespace>')
         @children = []
         @next_comments = []
         @final = final
+        @sealed = sealed
         yield_self(&block) if block
       end
 
@@ -52,6 +55,11 @@ module Parlour
       # @return [Boolean]
       attr_reader :final
 
+      sig { returns(T::Boolean) }
+      # Whether this namespace is sealed.
+      # @return [Boolean]
+      attr_reader :sealed
+
       sig { returns(T::Array[RbiObject]) }
       # The child {RbiObject} instances inside this namespace.
       # @return [Array<RbiObject>]
@@ -98,28 +106,31 @@ module Parlour
         )
       end
 
-      sig { params(object: T.untyped, block: T.proc.params(x: Namespace).void).void }
-      # Given a Class or Module object, generates all classes and modules in the
-      # path to that object, then executes the given block on the last
-      # {Namespace}. This should only be executed on the root namespace.
-      # @param [Class, Module] object
+      sig { params(constant: Module, block: T.proc.params(x: Namespace).void).void }
+      # Given a constant (i.e. a Module instance), generates all classes
+      # and modules in the path to that object, then executes the given
+      # block on the last {Namespace}. This should only be executed on
+      # the root namespace.
+      # @param [Module] constant
       # @param block A block which the new {Namespace} yields itself to.
-      def path(object, &block)
+      def path(constant, &block)
         raise 'only call #path on root' if is_a?(ClassNamespace) || is_a?(ModuleNamespace)
 
-        parts = object.to_s.split('::')
-        parts_with_types = parts.size.times.map do |i|
-          [parts[i], Module.const_get(parts[0..i].join('::')).class]
-        end
+        constant_name = T.let(Module.instance_method(:name).bind(constant).call, T.nilable(String))
+        raise 'given constant does not have a name' unless constant_name
 
         current_part = self
-        parts_with_types.each do |(name, type)|
-          if type == Class
+        constant_name.split('::').each_with_object([]) do |name, namespace|
+          namespace << name
+          instance = Module.const_get(namespace.join("::"))
+
+          case instance
+          when Class
             current_part = current_part.create_class(name)
-          elsif type == Module
+          when Module
             current_part = current_part.create_module(name)
           else
-            raise "unexpected type: path part #{name} is a #{type}"
+            raise "unexpected type: path part #{name} is a #{instance.class}"
           end
         end
 
@@ -151,6 +162,7 @@ module Parlour
         params(
           name: String,
           final: T::Boolean,
+          sealed: T::Boolean,
           superclass: T.nilable(String),
           abstract: T::Boolean,
           block: T.nilable(T.proc.params(x: ClassNamespace).void)
@@ -168,13 +180,14 @@ module Parlour
       #
       # @param name [String] The name of this class.
       # @param final [Boolean] Whether this namespace is final.
+      # @param sealed [Boolean] Whether this namespace is sealed.
       # @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 [ClassNamespace]
-      def create_class(name, final: false, superclass: nil, abstract: false, &block)
-        new_class = ClassNamespace.new(generator, name, final, superclass, abstract, &block)
+      def create_class(name, final: false, sealed: false, superclass: nil, abstract: false, &block)
+        new_class = ClassNamespace.new(generator, name, final, sealed, superclass, abstract, &block)
         move_next_comments(new_class)
         children << new_class
         new_class
@@ -184,6 +197,7 @@ module Parlour
         params(
           name: String,
           final: T::Boolean,
+          sealed: T::Boolean,
           enums: T.nilable(T::Array[T.any([String, String], String)]),
           abstract: T::Boolean,
           block: T.nilable(T.proc.params(x: EnumClassNamespace).void)
@@ -196,12 +210,13 @@ module Parlour
       #
       # @param name [String] The name of this class.
       # @param final [Boolean] Whether this namespace is final.
+      # @param sealed [Boolean] Whether this namespace is sealed.
       # @param enums [Array<(String, String), String>] The values of the enumeration.
       # @param abstract [Boolean] A boolean indicating whether this class is abstract.
       # @param block A block which the new instance yields itself to.
       # @return [EnumClassNamespace]
-      def create_enum_class(name, final: false, enums: nil, abstract: false, &block)
-        new_enum_class = EnumClassNamespace.new(generator, name, final, enums || [], abstract, &block)
+      def create_enum_class(name, final: false, sealed: false, enums: nil, abstract: false, &block)
+        new_enum_class = EnumClassNamespace.new(generator, name, final, sealed, enums || [], abstract, &block)
         move_next_comments(new_enum_class)
         children << new_enum_class
         new_enum_class
@@ -211,6 +226,7 @@ module Parlour
         params(
           name: String,
           final: T::Boolean,
+          sealed: T::Boolean,
           props: T.nilable(T::Array[StructProp]),
           abstract: T::Boolean,
           block: T.nilable(T.proc.params(x: StructClassNamespace).void)
@@ -225,12 +241,13 @@ module Parlour
       #
       # @param name [String] The name of this class.
       # @param final [Boolean] Whether this namespace is final.
+      # @param sealed [Boolean] Whether this namespace is sealed.
       # @param props [Array<StructProp>] The props of the struct.
       # @param abstract [Boolean] A boolean indicating whether this class is abstract.
       # @param block A block which the new instance yields itself to.
       # @return [EnumClassNamespace]
-      def create_struct_class(name, final: false, props: nil, abstract: false, &block)
-        new_struct_class = StructClassNamespace.new(generator, name, final, props || [], abstract, &block)
+      def create_struct_class(name, final: false, sealed: false, props: nil, abstract: false, &block)
+        new_struct_class = StructClassNamespace.new(generator, name, final, sealed, props || [], abstract, &block)
         move_next_comments(new_struct_class)
         children << new_struct_class
         new_struct_class
@@ -240,7 +257,9 @@ module Parlour
         params(
           name: String,
           final: T::Boolean,
+          sealed: T::Boolean,
           interface: T::Boolean,
+          abstract: T::Boolean,
           block: T.nilable(T.proc.params(x: ClassNamespace).void)
         ).returns(ModuleNamespace)
       end
@@ -256,12 +275,15 @@ module Parlour
       #
       # @param name [String] The name of this module.
       # @param final [Boolean] Whether this namespace is final.
+      # @param sealed [Boolean] Whether this namespace is sealed.
       # @param interface [Boolean] A boolean indicating whether this module is an
       #   interface.
+      # @param abstract [Boolean] A boolean indicating whether this module is
+      #   abstract.
       # @param block A block which the new instance yields itself to.
       # @return [ModuleNamespace]
-      def create_module(name, final: false, interface: false, &block)
-        new_module = ModuleNamespace.new(generator, name, final, interface, &block)
+      def create_module(name, final: false, sealed: false, interface: false, abstract: false, &block)
+        new_module = ModuleNamespace.new(generator, name, final, sealed, interface, abstract, &block)
         move_next_comments(new_module)
         children << new_module
         new_module
@@ -657,6 +679,7 @@ module Parlour
         result = []
 
         result += [options.indented(indent_level, 'final!'), ''] if final
+        result += [options.indented(indent_level, 'sealed!'), ''] if sealed
 
         # Split away the eigen constants; these need to be put in a
         # "class << self" block later