parlour 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd7b82a40507591cd3793427e52978d215cc70c12b94b1c80fa40909fe73f194
-  data.tar.gz: e2408f44d246e5090ab375a9ab5bba9bc733496f8d8b647576f6733d9aeeb48d
+  metadata.gz: d63ab49b1b2dd56c64f1b61dcfea11d04e4b3e4f90f85b17aa61b70de1bb420f
+  data.tar.gz: 0ff645332e076125f9e5ade86b06ad6a1ccc6b40698e29cbfd512f64c90bb5d7
 SHA512:
-  metadata.gz: bbb37ea0acb6091856f17d7a03cabf1c5b642e2571e47729e4232cda58da81da7dcc9477fe4f6d849f72afda6cc20f7c07310f44290079e1eded985719574a94
-  data.tar.gz: 5803b1fb765174873b3e8f45667b81da60d438d9209ee23d8fb860d391c02b1a6e1fabed9eb6cab14ec5f1d90bf6a37a78ba8edac887a0419ef1efd44f778afa
+  metadata.gz: 7f3f908f8a601e8d2555a857470a3d6248ee72af46b63f82a8c44690dc669b8bd894bde4a77b260a433177005517aa88e5994fa593511df99ab9180c99d260af
+  data.tar.gz: dee86c23d9f928a0bef5eae82374914b72dc490b278863506f71cc120757e9d882df2f4aaf73feb2cd3fc8f0658a0c0f8534c99e016dd6a1e36a764aaf5a6cbc

data/CHANGELOG.md

@@ -3,6 +3,18 @@ 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.6.0] - 2019-07-25
+### Changed
+- **Breaking change: the `name: ` keyword argument is now positional instead.**
+Instead of `create_method(name: 'A', returns: 'String')`, use
+`create_method('A', returns: 'String')`.
+- Altered some syntax to improve compatibility with previous Ruby versions.
+(Full compatibility is still WIP.)
+
+### Fixed
+- Fixed some Sorbet type signatures.
+- Fixed an RSpec warning.
+
 ## [0.5.2] - 2019-07-24
 ### Added
 - Added the `Namespace#create_includes` and `Namespace#create_extends` methods

data/README.md

@@ -35,15 +35,15 @@ Here's a quick example of how you can generate an RBI:
 require 'parlour'
 
 generator = Parlour::RbiGenerator.new
-generator.root.create_module(name: 'A') do |a|
-  a.create_class(name: 'Foo') do |foo|
-    foo.create_method(name: 'add_two_integers', parameters: [
-      Parlour::RbiGenerator::Parameter.new(name: 'a', type: 'Integer'),
-      Parlour::RbiGenerator::Parameter.new(name: 'b', type: 'Integer')
+generator.root.create_module('A') do |a|
+  a.create_class('Foo') do |foo|
+    foo.create_method('add_two_integers', parameters: [
+      Parlour::RbiGenerator::Parameter.new('a', type: 'Integer'),
+      Parlour::RbiGenerator::Parameter.new('b', type: 'Integer')
     ], return_type: 'Integer')
   end
 
-  a.create_class(name: 'Bar', superclass: 'Foo')
+  a.create_class('Bar', superclass: 'Foo')
 end
 
 generator.rbi # => Our RBI as a string
@@ -74,15 +74,15 @@ require 'parlour'
 
 class MyPlugin < Parlour::Plugin
   def generate(root)
-    root.create_module(name: 'A') do |a|
-      a.create_class(name: 'Foo') do |foo|
-        foo.create_method(name: 'add_two_integers', parameters: [
-          Parlour::RbiGenerator::Parameter.new(name: 'a', type: 'Integer'),
-          Parlour::RbiGenerator::Parameter.new(name: 'b', type: 'Integer')
+    root.create_module('A') do |a|
+      a.create_class('Foo') do |foo|
+        foo.create_method('add_two_integers', parameters: [
+          Parlour::RbiGenerator::Parameter.new('a', type: 'Integer'),
+          Parlour::RbiGenerator::Parameter.new('b', type: 'Integer')
         ], return_type: 'Integer')
       end
 
-      a.create_class(name: 'Bar', superclass: 'Foo')
+      a.create_class('Bar', superclass: 'Foo')
     end
   end
 end

data/Rakefile

@@ -1,6 +1,11 @@
 require 'rspec/core/rake_task'
 
-task :default => [:spec]
+task :default => [:tc, :spec]
 
 desc "Run the specs."
 RSpec::Core::RakeTask.new
+
+desc "Run the Sorbet type checker."
+task :tc do
+  system("bundle exec srb tc") || abort
+end

data/lib/parlour/plugin.rb

@@ -28,7 +28,7 @@ module Parlour
       registered_plugins[T.must(new_plugin.name)] = new_plugin
     end
 
-    sig { params(plugins: T::Array[Plugin], generator: RbiGenerator).void }
+    sig { params(plugins: T::Array[Plugin], generator: RbiGenerator, allow_failure: T::Boolean).void }
     # Runs an array of plugins on a given generator instance.
     #
     # @param plugins [Array<Plugin>] An array of {Plugin} instances.

data/lib/parlour/rbi_generator/attribute.rb

@@ -35,7 +35,7 @@ module Parlour
           super(generator, name, [], type, &block)
         when :writer
           super(generator, name, [
-            Parameter.new(name: name, type: type)
+            Parameter.new(name, type: type)
           ], type, &block)
         else
           raise 'unknown kind'

data/lib/parlour/rbi_generator/namespace.rb

@@ -96,9 +96,9 @@ module Parlour
         current_part = self
         parts_with_types.each do |(name, type)|
           if type == Class
-            current_part = current_part.create_class(name: name)
+            current_part = current_part.create_class(name)
           elsif type == Module
-            current_part = current_part.create_module(name: name)
+            current_part = current_part.create_module(name)
           else
             raise "unexpected type: path part #{name} is a #{type}"
           end
@@ -112,11 +112,11 @@ module Parlour
       #
       # @example Creating a module with a comment.
       #   namespace.add_comment_to_next_child('This is a module')
-      #   namespace.create_module(name: 'M')
+      #   namespace.create_module('M')
       #
       # @example Creating a class with a multi-line comment.
       #   namespace.add_comment_to_next_child(['This is a multi-line comment!', 'It can be as long as you want!'])
-      #   namespace.create_class(name: 'C')
+      #   namespace.create_class('C')
       #
       # @param comment [String, Array<String>] The new comment(s).
       # @return [void]
@@ -139,12 +139,12 @@ module Parlour
       # Creates a new class definition as a child of this namespace.
       #
       # @example Create a class with a nested module.
-      #   namespace.create_class(name: 'Foo') do |foo|
-      #     foo.create_module(name: 'Bar')
+      #   namespace.create_class('Foo') do |foo|
+      #     foo.create_module('Bar')
       #   end
       #
       # @example Create a class that is the child of another class.
-      #   namespace.create_class(name: 'Bar', superclass: 'Foo') #=> class Bar < Foo
+      #   namespace.create_class('Bar', superclass: 'Foo') #=> class Bar < Foo
       #
       # @param name [String] The name of this class.
       # @param superclass [String, nil] The superclass of this class, or nil if it doesn't
@@ -152,7 +152,7 @@ module Parlour
       # @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)
+      def create_class(name, superclass: nil, abstract: false, &block)
         new_class = ClassNamespace.new(generator, name, superclass, abstract, &block)
         move_next_comments(new_class)
         children << new_class
@@ -169,11 +169,11 @@ module Parlour
       # Creates a new module definition as a child of this namespace.
       #
       # @example Create a basic module.
-      #   namespace.create_module(name: 'Foo')
+      #   namespace.create_module('Foo')
       #
       # @example Create a module with a method.
-      #   namespace.create_module(name: 'Foo') do |foo|
-      #     foo.create_method(name: 'method_name', parameters: [], return_type: 'Integer')
+      #   namespace.create_module('Foo') do |foo|
+      #     foo.create_method('method_name', parameters: [], return_type: 'Integer')
       #   end
       #
       # @param name [String] The name of this module.
@@ -181,7 +181,7 @@ module Parlour
       #   interface.
       # @param block A block which the new instance yields itself to.
       # @return [ModuleNamespace]
-      def create_module(name:, interface: false, &block)
+      def create_module(name, interface: false, &block)
         new_module = ModuleNamespace.new(generator, name, interface, &block)
         move_next_comments(new_module)
         children << new_module
@@ -221,7 +221,7 @@ module Parlour
       #   it is defined using +self.+.
       # @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, &block)
+      def create_method(name, parameters: nil, return_type: nil, returns: nil, abstract: false, implementation: false, override: false, overridable: false, class_method: false, &block)
         parameters = parameters || []
         raise 'cannot specify both return_type: and returns:' if return_type && returns
         return_type ||= returns
@@ -266,7 +266,7 @@ module Parlour
       #   +"String"+ or +"T.untyped"+.
       # @param block A block which the new instance yields itself to.
       # @return [RbiGenerator::Attribute]
-      def create_attribute(name:, kind:, type:, &block)
+      def create_attribute(name, kind:, type:, &block)
         new_attribute = RbiGenerator::Attribute.new(
           generator,
           name,
@@ -287,8 +287,8 @@ module Parlour
       #   +"String"+ or +"T.untyped"+.
       # @param block A block which the new instance yields itself to.
       # @return [RbiGenerator::Attribute]
-      def create_attr_reader(name:, type:, &block)
-        create_attribute(name: name, kind: :reader, type: type, &block)
+      def create_attr_reader(name, type:, &block)
+        create_attribute(name, kind: :reader, type: type, &block)
       end
 
       # Creates a new write-only attribute (+attr_writer+).
@@ -298,8 +298,8 @@ module Parlour
       #   +"String"+ or +"T.untyped"+.
       # @param block A block which the new instance yields itself to.
       # @return [RbiGenerator::Attribute]
-      def create_attr_writer(name:, type:, &block)
-        create_attribute(name: name, kind: :writer, type: type, &block)
+      def create_attr_writer(name, type:, &block)
+        create_attribute(name, kind: :writer, type: type, &block)
       end
 
       # Creates a new read and write attribute (+attr_accessor+).
@@ -309,8 +309,8 @@ module Parlour
       #   +"String"+ or +"T.untyped"+.
       # @param block A block which the new instance yields itself to.
       # @return [RbiGenerator::Attribute]
-      def create_attr_accessor(name:, type:, &block)
-        create_attribute(name: name, kind: :accessor, type: type, &block)
+      def create_attr_accessor(name, type:, &block)
+        create_attribute(name, kind: :accessor, type: type, &block)
       end
 
       # Creates a new arbitrary code section.
@@ -334,13 +334,13 @@ module Parlour
       # Adds a new +extend+ to this namespace.
       #
       # @example Add an +extend+ to a class.
-      #   class.create_extend(name: 'ExtendableClass') #=> extend ExtendableClass
+      #   class.create_extend('ExtendableClass') #=> extend ExtendableClass
       #
       # @param object [String] A code string for what is extended, for example
       #   +"MyModule"+.
       # @param block A block which the new instance yields itself to.
       # @return [RbiGenerator::Extend]
-      def create_extend(name:, &block)
+      def create_extend(name, &block)
         new_extend = RbiGenerator::Extend.new(
           generator,
           name: name,
@@ -362,7 +362,7 @@ module Parlour
       def create_extends(extendables)
         returned_extendables = []
         extendables.each do |extendable|
-          returned_extendables << create_extend(name: extendable)
+          returned_extendables << create_extend(extendable)
         end
         returned_extendables
       end
@@ -371,13 +371,13 @@ module Parlour
       # Adds a new +include+ to this namespace.
       #
       # @example Add an +include+ to a class.
-      #   class.create_include(name: 'IncludableClass') #=> include IncludableClass
+      #   class.create_include('IncludableClass') #=> include IncludableClass
       #
       # @param [String] name A code string for what is included, for example
       #   +"Enumerable"+.
       # @param block A block which the new instance yields itself to.
       # @return [RbiGenerator::Include]
-      def create_include(name:, &block)
+      def create_include(name, &block)
         new_include = RbiGenerator::Include.new(
           generator,
           name: name,
@@ -399,7 +399,7 @@ module Parlour
       def create_includes(includables)
         returned_includables = []
         includables.each do |includable|
-          returned_includables << create_include(name: includable)
+          returned_includables << create_include(includable)
         end
         returned_includables
       end
@@ -408,13 +408,13 @@ module Parlour
       # Adds a new constant definition to this namespace.
       #
       # @example Add an +Elem+ constant to the class.
-      #   class.create_constant(name: 'Elem', value: 'String') #=> Elem = String
+      #   class.create_constant('Elem', value: 'String') #=> Elem = String
       #
       # @param name [String] The name of the constant.
       # @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:, value:, &block)
+      def create_constant(name, value:, &block)
         new_constant = RbiGenerator::Constant.new(
           generator,
           name: name,

data/lib/parlour/rbi_generator/parameter.rb

@@ -15,13 +15,13 @@ module Parlour
       # Create a new method parameter.
       #
       # @example Create a simple Integer parameter named +num+.
-      #   Parlour::RbiGenerator::Parameter.new(name: 'num', type: 'Integer')
+      #   Parlour::RbiGenerator::Parameter.new('num', type: 'Integer')
       # @example Create a nilable array parameter.
-      #   Parlour::RbiGenerator::Parameter.new(name: 'array_of_strings_or_symbols', type: 'T.nilable(T::Array(String, Symbol))')
+      #   Parlour::RbiGenerator::Parameter.new('array_of_strings_or_symbols', type: 'T.nilable(T::Array(String, Symbol))')
       # @example Create a block parameter.
-      #   Parlour::RbiGenerator::Parameter.new(name: '&blk', type: 'T.proc.void')
+      #   Parlour::RbiGenerator::Parameter.new('&blk', type: 'T.proc.void')
       # @example Create a parameter with a default value.
-      #   Parlour::RbiGenerator::Parameter.new(name: 'name', type: 'String', default: 'Parlour')
+      #   Parlour::RbiGenerator::Parameter.new('name', type: 'String', default: 'Parlour')
       #
       # @param name [String] The name of this parameter. This may start with +*+, +**+,
       #   or +&+, or end with +:+, which will infer the {kind} of this
@@ -33,7 +33,7 @@ module Parlour
       #   as +"\"\""+ (or +'""'+). The default value of the decimal +3.14+
       #   would be +"3.14"+.
       # @return [void]
-      def initialize(name: nil, type: nil, default: nil)
+      def initialize(name, type: nil, default: nil)
         name = T.must(name)
         @name = name
 

data/lib/parlour/rbi_generator/rbi_object.rb

@@ -52,12 +52,12 @@ module Parlour
       # the definition for this object, not in the definition's body.
       #
       # @example Creating a module with a comment.
-      #   namespace.create_module(name: 'M') do |m|
+      #   namespace.create_module('M') do |m|
       #     m.add_comment('This is a module')
       #   end
       #
       # @example Creating a class with a multi-line comment.
-      #   namespace.create_class(name: 'C') do |c|
+      #   namespace.create_class('C') do |c|
       #     c.add_comment(['This is a multi-line comment!', 'It can be as long as you want!'])
       #   end
       #

data/lib/parlour/version.rb

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

data/parlour.gemspec

@@ -28,6 +28,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "sorbet"
+  spec.add_development_dependency "sorbet", "= 0.4.4254"
   spec.add_development_dependency "simplecov"
 end

data/plugin_examples/foobar_plugin.rb

@@ -3,10 +3,10 @@ require 'parlour'
 module FooBar
   class Plugin < Parlour::Plugin
     def generate(root)
-      root.create_module(name: 'Foo') do |foo|
+      root.create_module('Foo') do |foo|
         foo.add_comment('This is an example plugin!')
-        foo.create_module(name: 'Bar')
-        foo.create_module(name: 'Bar', interface: true)
+        foo.create_module('Bar')
+        foo.create_module('Bar', interface: true)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parlour
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Aaron Christiansen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-07-24 00:00:00.000000000 Z
+date: 2019-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -84,16 +84,16 @@ dependencies:
   name: sorbet
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.4.4254
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.4.4254
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement