parlour 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fab83bcce7bff17a6f4ded59f19e36b35f61b96c0e4c8e1ef50e5f0856e79fb
-  data.tar.gz: 1173903dcff90d2fe2579dbb0e79d361707f6d33041c6c36295f09f43219c630
+  metadata.gz: ded8584a233720f5a345d5bad9b91c344fc12f1dc38b0fbad1b3e0e797178cb9
+  data.tar.gz: c23b9bc0207031d207202d95e259521fa4b5826b739094c2f10cab5223392f9b
 SHA512:
-  metadata.gz: 0d3a8e0ac15d49a7cac530bc74c31070532a3960ff7cdaac1d70ab2bb28eeba8e6664125bc1bb52b9c676dcd934c0b31c24c97da02bfb1f65ef411dc480b28a9
-  data.tar.gz: 64d2b979abc0ded7506f1dd176269be3c84f39d972d038bedd3c2d0d34262b464dad0de1daf8591543444cdf0f403a9dc5bc648704429a1b3e61acd45a8dc54f
+  metadata.gz: 2f470194db52dd83dbb27df91f3f9044f921946471a800f7d2d42e7f6230496b326585847812c35d77a7cea1eb1a2f874dc1397b9fc4b96bd53f8c2b13d31b4a
+  data.tar.gz: 270d77587338e413141952ce06710774e468a91f7ec636cf2636f2856a1bae4a3e9d4852a643aad602f57d0cb30cac88b080b0c46b22395e1905e69a0c56d28c

data/CHANGELOG.md

@@ -3,6 +3,11 @@ 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.3.0] - 2019-07-09
+### Changed
+- Breaking change: all `Namespace#create_` methods, and the `Parameter` constructor, now take entirely keyword arguments.
+  For example, `create_method('A', [], 'String')` is now written as `create_method(name: 'A', returns: 'String')`.
+
 ## [0.2.2] - 2019-07-08
 ### Fixed
 - Fixed a bug which occasionally caused includes and extends to generate incorrectly.

data/README.md

@@ -25,15 +25,15 @@ API is very likely to change:
 require 'parlour'
 
 generator = Parlour::RbiGenerator.new
-generator.root.create_module('A') do |a|
-  a.create_class('Foo') do |foo|
-    foo.create_method('add_two_integers', [
-      Parlour::RbiGenerator::Parameter.new('a', type: 'Integer'),
-      Parlour::RbiGenerator::Parameter.new('b', type: 'Integer')
-    ], 'Integer')
+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')
+    ], return_type: 'Integer')
   end
 
-  a.create_class('Bar', superclass: 'Foo')
+  a.create_class(name: 'Bar', superclass: 'Foo')
 end
 
 generator.rbi # => Our RBI as a string
@@ -64,15 +64,15 @@ require 'parlour'
 
 class MyPlugin < Parlour::Plugin
   def generate(root)
-    root.create_module('A') do |a|
-      a.create_class('Foo') do |foo|
-        foo.create_method('add_two_integers', [
-          Parlour::RbiGenerator::Parameter.new('a', type: 'Integer'),
-          Parlour::RbiGenerator::Parameter.new('b', type: 'Integer')
-        ], 'Integer')
+    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')
+        ], return_type: 'Integer')
       end
 
-      a.create_class('Bar', superclass: 'Foo')
+      a.create_class(name: 'Bar', superclass: 'Foo')
     end
   end
 end

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, type: type)
+            Parameter.new(name: name, type: type)
           ], type, &block)
         else
           raise 'unknown kind'

data/lib/parlour/rbi_generator/namespace.rb

@@ -75,11 +75,11 @@ module Parlour
       #
       # @example Creating a module with a comment.
       #   namespace.add_comment_to_next_child('This is a module')
-      #   namespace.create_module('M')
+      #   namespace.create_module(name: '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('C')
+      #   namespace.create_class(name: 'C')
       #
       # @param comment [String, Array<String>] The new comment(s).
       # @return [void]
@@ -93,7 +93,7 @@ module Parlour
 
       sig do
         params(
-          name: String,
+          name: T.nilable(String),
           superclass: T.nilable(String),
           abstract: T::Boolean,
           block: T.nilable(T.proc.params(x: ClassNamespace).void)
@@ -102,12 +102,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('Foo') do |foo|
-      #     foo.create_module('Bar')
+      #   namespace.create_class(name: 'Foo') do |foo|
+      #     foo.create_module(name: 'Bar')
       #   end
       #
       # @example Create a class that is the child of another class.
-      #   namespace.create_class('Bar', superclass: 'Foo') #=> class Bar < Foo
+      #   namespace.create_class(name: '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
@@ -115,7 +115,8 @@ 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: nil, superclass: nil, abstract: false, &block)
+        name = T.must(name)
         new_class = ClassNamespace.new(generator, name, superclass, abstract, &block)
         move_next_comments(new_class)
         children << new_class
@@ -124,7 +125,7 @@ module Parlour
 
       sig do
         params(
-          name: String,
+          name: T.nilable(String),
           interface: T::Boolean,
           block: T.nilable(T.proc.params(x: ClassNamespace).void)
         ).returns(ModuleNamespace)
@@ -132,11 +133,11 @@ module Parlour
       # Creates a new module definition as a child of this namespace.
       #
       # @example Create a basic module.
-      #   namespace.create_module('Foo')
+      #   namespace.create_module(name: 'Foo')
       #
       # @example Create a module with a method.
-      #   namespace.create_module('Foo') do |foo|
-      #     foo.create_method('method_name', [], 'Integer')
+      #   namespace.create_module(name: 'Foo') do |foo|
+      #     foo.create_method(name: 'method_name', parameters: [], return_type: 'Integer')
       #   end
       #
       # @param name [String] The name of this module.
@@ -144,7 +145,8 @@ 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: nil, interface: false, &block)
+        name = T.must(name)
         new_module = ModuleNamespace.new(generator, name, interface, &block)
         move_next_comments(new_module)
         children << new_module
@@ -153,9 +155,10 @@ module Parlour
 
       sig do
         params(
-          name: String,
-          parameters: T::Array[Parameter],
+          name: T.nilable(String),
+          parameters: T.nilable(T::Array[Parameter]),
           return_type: T.nilable(String),
+          returns: T.nilable(String),
           abstract: T::Boolean,
           implementation: T::Boolean,
           override: T::Boolean,
@@ -172,6 +175,7 @@ module Parlour
       #   method's parameters.
       # @param return_type [String, nil] A Sorbet string of what this method returns, such as
       #   +"String"+ or +"T.untyped"+. Passing nil denotes a void return.
+      # @param returns [String, nil] Same as return_type.
       # @param abstract [Boolean] Whether this method is abstract.
       # @param implementation [Boolean] Whether this method is an implementation of a
       #   parent abstract method.
@@ -182,7 +186,11 @@ 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, return_type = nil, abstract: false, implementation: false, override: false, overridable: false, class_method: false, &block)
+      def create_method(name: nil, parameters: nil, return_type: nil, returns: nil, abstract: false, implementation: false, override: false, overridable: false, class_method: false, &block)
+        name = T.must(name)
+        parameters = parameters || []
+        raise 'cannot specify both return_type: and returns:' if return_type && returns
+        return_type ||= returns
         new_method = RbiGenerator::Method.new(
           generator,
           name,
@@ -224,7 +232,10 @@ 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: nil, kind: nil, type: nil, &block)
+        name = T.must(name)
+        kind = T.must(kind)
+        type = T.must(type)
         new_attribute = RbiGenerator::Attribute.new(
           generator,
           name,
@@ -245,8 +256,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, :reader, type, &block)
+      def create_attr_reader(name: nil, type: nil, &block)
+        create_attribute(name: name, kind: :reader, type: type, &block)
       end
 
       # Creates a new write-only attribute (+attr_writer+).
@@ -256,8 +267,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, :writer, type, &block)
+      def create_attr_writer(name: nil, type: nil, &block)
+        create_attribute(name: name, kind: :writer, type: type, &block)
       end
 
       # Creates a new read and write attribute (+attr_accessor+).
@@ -267,8 +278,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, :accessor, type, &block)
+      def create_attr_accessor(name: nil, type: nil, &block)
+        create_attribute(name: name, kind: :accessor, type: type, &block)
       end
 
       sig { params(name: String).void }

data/lib/parlour/rbi_generator/parameter.rb

@@ -7,7 +7,7 @@ module Parlour
 
       sig do
         params(
-          name: String,
+          name: T.nilable(String),
           type: T.nilable(String),
           default: T.nilable(String)
         ).void
@@ -15,13 +15,13 @@ module Parlour
       # Create a new method parameter.
       #
       # @example Create a simple Integer parameter named +num+.
-      #   Parlour::RbiGenerator::Parameter.new('num', type: 'Integer')
+      #   Parlour::RbiGenerator::Parameter.new(name: 'num', type: 'Integer')
       # @example Create a nilable array parameter.
-      #   Parlour::RbiGenerator::Parameter.new('array_of_strings_or_symbols', type: 'T.nilable(T::Array(String, Symbol))')
+      #   Parlour::RbiGenerator::Parameter.new(name: 'array_of_strings_or_symbols', type: 'T.nilable(T::Array(String, Symbol))')
       # @example Create a block parameter.
-      #   Parlour::RbiGenerator::Parameter.new('&blk', type: 'T.proc.void')
+      #   Parlour::RbiGenerator::Parameter.new(name: '&blk', type: 'T.proc.void')
       # @example Create a parameter with a default value.
-      #   Parlour::RbiGenerator::Parameter.new('name', type: 'String', default: 'Parlour')
+      #   Parlour::RbiGenerator::Parameter.new(name: '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,8 @@ module Parlour
       #   as +"\"\""+ (or +'""'+). The default value of the decimal +3.14+
       #   would be +"3.14"+.
       # @return [void]
-      def initialize(name, type: nil, default: nil)
+      def initialize(name: nil, type: nil, default: nil)
+        name = T.must(name)
         @name = name
 
         prefix = /^(\*\*|\*|\&)?/.match(name)&.captures&.first || ''

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('M') do |m|
+      #   namespace.create_module(name: 'M') do |m|
       #     m.add_comment('This is a module')
       #   end
       #
       # @example Creating a class with a multi-line comment.
-      #   namespace.create_class('C') do |c|
+      #   namespace.create_class(name: '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.2.2'
+  VERSION = '0.3.0'
 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('Foo') do |foo|
+      root.create_module(name: 'Foo') do |foo|
         foo.add_comment('This is an example plugin!')
-        foo.create_module('Bar')
-        foo.create_module('Bar', interface: true)
+        foo.create_module(name: 'Bar')
+        foo.create_module(name: 'Bar', interface: true)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parlour
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Aaron Christiansen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-07-08 00:00:00.000000000 Z
+date: 2019-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime