parlour 0.8.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a670215d6246dfe4cc4aec9e3dd5121cf1da1357dbc1703a53dd059d3467d47
-  data.tar.gz: 6c8fa32d0adb363b72d43e307fb38c443dd469444ffbefddaa561e841b108846
+  metadata.gz: f603ddca16331f43a36b4120b7d12aa5a4b7c83f753e8527b91bc1391109e9fe
+  data.tar.gz: f550cdf4cc358dd6ac0c21853ad26756d4729c7f28f3695af53d25775b3f45f0
 SHA512:
-  metadata.gz: '0089e4ef2b9cf1855bba3e1a8a1a5faeae2a020003c9625ef95e96fb7c6b0293cf44cf8fda4a2a312fe3ea91d9b10e05cd70d83b96cc80eb1354741958210140'
-  data.tar.gz: b9554148306f4a0453cf4d6e9244581a6380df6341d0ec88033b91c917ef4a1d9e67f7448cc51758b7ec8c98044583810ccb68ad5a85aa3b221086e9c105844f
+  metadata.gz: a962191c42becbe6dbe213eb63be142df100643786006093e5663af51f80049890c26ff8974b718cfd89198387cf0ec801b8d3e10cbf032aaf3aa86f746fda97
+  data.tar.gz: 1bfafd7afbcf81105379d7b747e0c204e47fdd593b0b1a67e659275b0ebd8d236753e48b5bc05896e1e1759ac6495ad3e8132f85a497f28b35c436ddb3cb1585

data/CHANGELOG.md

@@ -3,6 +3,19 @@ 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/).
 
+## [1.0.0] - 2019-11-22
+### Added
+- `T::Enum` classes have been implemented, and can be generated using
+`#create_enum_class`.
+- Methods and namespaces can now be made final using the `final:` keyword
+argument.
+- Type aliases can be created on namespaces using `#create_type_alias`.
+- The `.parlour` file can now have globs in `relative_requires` to load many
+files matching a pattern at once.
+
+### Fixed
+- Commander is now a gemspec dependency.
+
 ## [0.8.1] - 2019-09-27
 ### Added
 - Running with the PARLOUR_DEBUG environment variable set will now print debug

data/README.md

@@ -9,7 +9,7 @@ Parlour is an RBI generator and merger for Sorbet. It consists of two key parts:
     an intuitive DSL.
 
   - The plugin/build system, which allows multiple Parlour plugins to generate
-    RBIs for the same codebase. These are combined automatically as much as 
+    RBIs for the same codebase. These are combined automatically as much as
     possible, but any other conflicts can be resolved manually through prompts.
 
 ## Why should I use this?
@@ -64,7 +64,7 @@ end
 ```
 
 ### Writing a plugin
-Plugins are better than using the generator alone, as your plugin can be 
+Plugins are better than using the generator alone, as your plugin can be
 combined with others to produce larger RBIs without conflicts.
 
 We could write the above example as a plugin like this:
@@ -102,7 +102,8 @@ output_file: output.rbi
 
 relative_requires:
   - plugin.rb
-  
+  - app/models/*.rb
+
 plugins:
   MyPlugin: {}
 ```
@@ -125,7 +126,7 @@ output_file: output.rbi
 
 requires:
   - parlour-gem
-  
+
 plugins:
   MyPlugin: {}
 ```
@@ -139,7 +140,7 @@ requires:
   - gem1
   - gem2
   - gem3
-  
+
 plugins:
   Gem1::Plugin: {}
   Gem2::Plugin: {}

data/exe/parlour

@@ -36,7 +36,9 @@ command :run do |c|
 
     configuration[:requires].each { |source| require(source) }
     configuration[:relative_requires].each do |source|
-      require_relative(File.join(Dir.pwd, source))
+      Dir[File.join(Dir.pwd, source)].each do |file|
+        require_relative(file)
+      end
     end
 
     # Collect the instances of each plugin into an array
@@ -82,7 +84,7 @@ command :run do |c|
     unique_strictness_levels = requested_strictness_levels.uniq
     if unique_strictness_levels.empty?
       # If no requests were made, just use the default
-      strictness = 'strong' 
+      strictness = 'strong'
     else
       # Sort the strictnesses into "strictness order" and pick the weakest
       strictness = unique_strictness_levels.min_by do |level|
@@ -94,7 +96,7 @@ command :run do |c|
         puts Rainbow('Note: ').yellow.bold + "Plugins specified multiple strictness levels, chose the weakest (#{strictness})"
       end
     end
- 
+
     # Write the final RBI
     File.write(configuration[:output_file], gen.rbi(strictness))
   end

data/lib/parlour.rb

@@ -21,6 +21,7 @@ require 'parlour/rbi_generator/constant'
 require 'parlour/rbi_generator/namespace'
 require 'parlour/rbi_generator/module_namespace'
 require 'parlour/rbi_generator/class_namespace'
+require 'parlour/rbi_generator/enum_class_namespace'
 require 'parlour/rbi_generator'
 
 require 'parlour/conflict_resolver'

data/lib/parlour/rbi_generator/class_namespace.rb

@@ -9,6 +9,7 @@ module Parlour
         params(
           generator: RbiGenerator,
           name: String,
+          final: T::Boolean,
           superclass: T.nilable(String),
           abstract: T::Boolean,
           block: T.nilable(T.proc.params(x: ClassNamespace).void)
@@ -19,13 +20,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 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, abstract, &block)
-        super(generator, name, &block)
+      def initialize(generator, name, final, superclass, abstract, &block)
+        super(generator, name, final, &block)
         @superclass = superclass
         @abstract = abstract
       end

data/lib/parlour/rbi_generator/enum_class_namespace.rb

@@ -0,0 +1,90 @@
+# typed: true
+module Parlour
+  class RbiGenerator
+    # Represents an enum definition; that is, a class with an +enum+ call.
+    class EnumClassNamespace < ClassNamespace
+      extend T::Sig
+
+      sig do
+        params(
+          generator: RbiGenerator,
+          name: String,
+          final: T::Boolean,
+          enums: T::Array[T.any([String, String], String)],
+          abstract: T::Boolean,
+          block: T.nilable(T.proc.params(x: EnumClassNamespace).void)
+        ).void
+      end
+      # Creates a new enum class definition.
+      # @note You should use {Namespace#create_class} rather than this directly.
+      #
+      # @param generator [RbiGenerator] The current RbiGenerator.
+      # @param name [String] The name of this class.
+      # @param final [Boolean] Whether this namespace is final.
+      # @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)
+        @enums = enums
+      end
+
+      sig { returns(T::Array[T.any([String, String], String)]) }
+      # The values of the enumeration.
+      # @return [Array<(String, String), String>]
+      attr_reader :enums
+
+      sig do
+        override.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      # Generates the RBI lines for the body of this enum. This consists of
+      # {enums}, {includes}, {extends} and {children}.
+      #
+      # @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 for the body, formatted as specified.
+      def generate_body(indent_level, options)
+        result = [options.indented(indent_level, 'enums do')]
+        enums.each do |enum_value|
+          case enum_value
+          when String
+            line = "#{enum_value} = new"
+          when Array
+            line = "#{enum_value[0]} = new(#{enum_value[1]})"
+          else
+            T.absurd(enum_value)
+          end
+
+          result << options.indented(indent_level + 1, line)
+        end
+        result << options.indented(indent_level, 'end')
+        result << ''
+
+        result + super
+      end
+
+      sig do
+        override.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).returns(T::Boolean)
+      end
+      # Given an array of {EnumClassNamespace} 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<RbiGenerator::RbiObject>] An array of other {EnumClassNamespace} instances.
+      # @return [Boolean] Whether this instance may be merged with them.
+      def mergeable?(others)
+        others = T.cast(others, T::Array[EnumClassNamespace]) rescue (return false)
+        all = others + [self]
+
+        T.must(super && all.map(&:enums).uniq.length <= 1)
+      end
+    end
+  end
+end

data/lib/parlour/rbi_generator/method.rb

@@ -16,6 +16,7 @@ module Parlour
           override: T::Boolean,
           overridable: T::Boolean,
           class_method: T::Boolean,
+          final: T::Boolean,
           type_parameters: T.nilable(T::Array[Symbol]),
           block: T.nilable(T.proc.params(x: Method).void)
         ).void
@@ -38,10 +39,11 @@ module Parlour
       # @param overridable [Boolean] Whether this method is overridable by subclasses.
       # @param class_method [Boolean] Whether this method is a class method; that is, it
       #   it is defined using +self.+.
-      # @param class_method [Array<Symbol>, nil] This method's type parameters.
+      # @param final [Boolean] Whether this method is final.
+      # @param type_parameters [Array<Symbol>, nil] This method's type parameters.
       # @param block A block which the new instance yields itself to.
       # @return [void]
-      def initialize(generator, name, parameters, return_type = nil, abstract: false, implementation: false, override: false, overridable: false, class_method: false, type_parameters: nil, &block)
+      def initialize(generator, name, parameters, return_type = nil, abstract: false, implementation: false, override: false, overridable: false, class_method: false, final: false, type_parameters: nil, &block)
         super(generator, name)
         @parameters = parameters
         @return_type = return_type
@@ -50,6 +52,7 @@ module Parlour
         @override = override
         @overridable = overridable
         @class_method = class_method
+        @final = final
         @type_parameters = type_parameters || []
         yield_self(&block) if block
       end
@@ -70,6 +73,7 @@ module Parlour
           override        == other.override &&
           overridable     == other.overridable &&
           class_method    == other.class_method &&
+          final           == other.final &&
           type_parameters == other.type_parameters
       end
 
@@ -114,6 +118,11 @@ module Parlour
       # @return [Boolean]
       attr_reader :class_method
 
+      sig { returns(T::Boolean) }
+      # Whether this method is final.
+      # @return [Boolean]
+      attr_reader :final
+
       sig { returns(T::Array[Symbol]) }
       # This method's type parameters.
       # @return [Array<Symbol>]
@@ -132,11 +141,12 @@ module Parlour
       # @return [Array<String>] The RBI lines, formatted as specified.
       def generate_rbi(indent_level, options)
         return_call = return_type ? "returns(#{return_type})" : 'void'
+        sig_args = final ? '(:final)' : ''
 
         sig_params = parameters.map(&:to_sig_param)
         sig_lines = parameters.length >= options.break_params \
           ? [
-              options.indented(indent_level, 'sig do'),
+              options.indented(indent_level, "sig#{sig_args} do"),
               options.indented(indent_level + 1, "#{qualifiers}params("),
             ] +
             (
@@ -155,7 +165,7 @@ module Parlour
 
           : [options.indented(
               indent_level,
-              "sig { #{parameters.empty? ? qualifiers[0...-1] : qualifiers}#{
+              "sig#{sig_args} { #{parameters.empty? ? qualifiers[0...-1] : qualifiers}#{
                 parameters.empty? ? '' : "params(#{sig_params.join(', ')})"
               }#{
                 qualifiers.empty? && parameters.empty? ? '' : '.'

data/lib/parlour/rbi_generator/module_namespace.rb

@@ -9,6 +9,7 @@ module Parlour
         params(
           generator: RbiGenerator,
           name: String,
+          final: T::Boolean,
           interface: T::Boolean,
           block: T.nilable(T.proc.params(x: ClassNamespace).void)
         ).void
@@ -18,12 +19,13 @@ module Parlour
       # 
       # @param generator [RbiGenerator] The current RbiGenerator.
       # @param name [String] The name of this module.
+      # @param final [Boolean] Whether this namespace is final.
       # @param interface [Boolean] A boolean indicating whether this module is an
       #   interface.
       # @param block A block which the new instance yields itself to.
       # @return [void]
-      def initialize(generator, name, interface, &block)
-        super(generator, name, &block)
+      def initialize(generator, name, final, interface, &block)
+        super(generator, name, final, &block)
         @name = name
         @interface = interface
       end

data/lib/parlour/rbi_generator/namespace.rb

@@ -26,6 +26,7 @@ module Parlour
         params(
           generator: RbiGenerator,
           name: T.nilable(String),
+          final: T::Boolean,
           block: T.nilable(T.proc.params(x: Namespace).void)
         ).void
       end
@@ -35,15 +36,22 @@ 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 block A block which the new instance yields itself to.
       # @return [void]
-      def initialize(generator, name = nil, &block)
+      def initialize(generator, name = nil, final = false, &block)
         super(generator, name || '<anonymous namespace>')
         @children = []
         @next_comments = []
+        @final = final
         yield_self(&block) if block
       end
 
+      sig { returns(T::Boolean) }
+      # Whether this namespace is final.
+      # @return [Boolean]
+      attr_reader :final
+
       sig { returns(T::Array[RbiObject]) }
       # The child {RbiObject} instances inside this namespace.
       # @return [Array<RbiObject>]
@@ -131,6 +139,7 @@ module Parlour
       sig do
         params(
           name: String,
+          final: T::Boolean,
           superclass: T.nilable(String),
           abstract: T::Boolean,
           block: T.nilable(T.proc.params(x: ClassNamespace).void)
@@ -147,13 +156,14 @@ module Parlour
       #   namespace.create_class('Bar', superclass: 'Foo') #=> class Bar < Foo
       #
       # @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 [ClassNamespace]
-      def create_class(name, superclass: nil, abstract: false, &block)
-        new_class = ClassNamespace.new(generator, name, superclass, abstract, &block)
+      def create_class(name, final: false, superclass: nil, abstract: false, &block)
+        new_class = ClassNamespace.new(generator, name, final, superclass, abstract, &block)
         move_next_comments(new_class)
         children << new_class
         new_class
@@ -162,6 +172,34 @@ module Parlour
       sig do
         params(
           name: String,
+          final: T::Boolean,
+          enums: T.nilable(T::Array[T.any([String, String], String)]),
+          abstract: T::Boolean,
+          block: T.nilable(T.proc.params(x: EnumClassNamespace).void)
+        ).returns(EnumClassNamespace)
+      end
+      # Creates a new enum class definition as a child of this namespace.
+      #
+      # @example Create a compass direction enum.
+      #   namespace.create_class('Direction', enums: ['North', 'South', 'East', 'West'])
+      #
+      # @param name [String] The name of this class.
+      # @param final [Boolean] Whether this namespace is final.
+      # @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)
+        move_next_comments(new_enum_class)
+        children << new_enum_class
+        new_enum_class
+      end
+
+      sig do
+        params(
+          name: String,
+          final: T::Boolean,
           interface: T::Boolean,
           block: T.nilable(T.proc.params(x: ClassNamespace).void)
         ).returns(ModuleNamespace)
@@ -177,12 +215,13 @@ module Parlour
       #   end
       #
       # @param name [String] The name of this module.
+      # @param final [Boolean] Whether this namespace is final.
       # @param interface [Boolean] A boolean indicating whether this module is an
       #   interface.
       # @param block A block which the new instance yields itself to.
       # @return [ModuleNamespace]
-      def create_module(name, interface: false, &block)
-        new_module = ModuleNamespace.new(generator, name, interface, &block)
+      def create_module(name, final: false, interface: false, &block)
+        new_module = ModuleNamespace.new(generator, name, final, interface, &block)
         move_next_comments(new_module)
         children << new_module
         new_module
@@ -199,6 +238,7 @@ module Parlour
           override: T::Boolean,
           overridable: T::Boolean,
           class_method: T::Boolean,
+          final: T::Boolean,
           type_parameters: T.nilable(T::Array[Symbol]),
           block: T.nilable(T.proc.params(x: Method).void)
         ).returns(Method)
@@ -220,10 +260,11 @@ module Parlour
       # @param overridable [Boolean] Whether this method is overridable by subclasses.
       # @param class_method [Boolean] Whether this method is a class method; that is, it
       #   it is defined using +self.+.
-      # @param class_method [Array<Symbol>, nil] This method's type parameters.
+      # @param final [Boolean] Whether this method is final.
+      # @param type_parameters [Array<Symbol>, nil] This method's type parameters.
       # @param block A block which the new instance yields itself to.
       # @return [Method]
-      def create_method(name, parameters: nil, return_type: nil, returns: nil, abstract: false, implementation: false, override: false, overridable: false, class_method: false, type_parameters: nil, &block)
+      def create_method(name, parameters: nil, return_type: nil, returns: nil, abstract: false, implementation: false, override: false, overridable: false, class_method: false, final: false, type_parameters: nil, &block)
         parameters = parameters || []
         raise 'cannot specify both return_type: and returns:' if return_type && returns
         return_type ||= returns
@@ -233,10 +274,11 @@ module Parlour
           parameters,
           return_type,
           abstract: abstract,
-          implementation: implementation, 
+          implementation: implementation,
           override: override,
           overridable: overridable,
           class_method: class_method,
+          final: final,
           type_parameters: type_parameters,
           &block
         )
@@ -478,6 +520,20 @@ module Parlour
         new_constant
       end
 
+      sig { params(name: String, type: String, block: T.nilable(T.proc.params(x: Constant).void)).returns(Constant) }
+      # Adds a new type alias, in the form of a constant, to this namespace.
+      #
+      # @example Add a +MyType+ type alias, to +Integer+, to the class.
+      #   class.create_type_alias('MyType', type: 'Integer') #=> MyType = T.type_alias { Integer }
+      #
+      # @param name [String] The name of the type alias.
+      # @param value [String] The type to alias, as a Ruby code string.
+      # @param block A block which the new instance yields itself to.
+      # @return [RbiGenerator::Constant]
+      def create_type_alias(name, type:, &block)
+        create_constant(name, value: "T.type_alias { #{type} }", &block)
+      end
+
       sig do
         override.overridable.params(
           others: T::Array[RbiGenerator::RbiObject]
@@ -526,7 +582,7 @@ module Parlour
       private
 
       sig do
-        params(
+        overridable.params(
           indent_level: Integer,
           options: Options
         ).returns(T::Array[String])
@@ -540,6 +596,8 @@ module Parlour
       def generate_body(indent_level, options)
         result = []
 
+        result += [options.indented(indent_level, 'final!'), ''] if final
+
         if includes.any? || extends.any? || constants.any?
           result += includes
             .flat_map { |x| x.generate_rbi(indent_level, options) }

data/lib/parlour/version.rb

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

data/parlour.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "sorbet-runtime"
   spec.add_dependency "rainbow", "~> 3.0.0"
+  spec.add_dependency "commander", "~> 4.4.0"
 
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 10.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parlour
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Aaron Christiansen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-09-27 00:00:00.000000000 Z
+date: 2019-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.4.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -138,6 +152,7 @@ files:
 - lib/parlour/rbi_generator/attribute.rb
 - lib/parlour/rbi_generator/class_namespace.rb
 - lib/parlour/rbi_generator/constant.rb
+- lib/parlour/rbi_generator/enum_class_namespace.rb
 - lib/parlour/rbi_generator/extend.rb
 - lib/parlour/rbi_generator/include.rb
 - lib/parlour/rbi_generator/method.rb