parlour 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2325cc0c8641efdbbf3499b4751f7e10dae39ee7823acb1a9588212711d9ceb
-  data.tar.gz: da88da407877745bb1f4265d0b90964881a2ef44bbd52566952dd18de467585c
+  metadata.gz: dd7b82a40507591cd3793427e52978d215cc70c12b94b1c80fa40909fe73f194
+  data.tar.gz: e2408f44d246e5090ab375a9ab5bba9bc733496f8d8b647576f6733d9aeeb48d
 SHA512:
-  metadata.gz: 12438efd38d62b16d90f93186014b666950ff178bf00c5522575b00f9222baad9ebc8b7c507df2618833b9a04c5b3fcf8542670600e29ddfb254addb167ad282
-  data.tar.gz: fae177ea2bede03f5e27264bfaa9b5064ac6685860b5a708a5370aa749278d34bebe06c12cd37580b6c26a1e1ff4f95c69d71ae2f56767cc30fd5901679ae453
+  metadata.gz: bbb37ea0acb6091856f17d7a03cabf1c5b642e2571e47729e4232cda58da81da7dcc9477fe4f6d849f72afda6cc20f7c07310f44290079e1eded985719574a94
+  data.tar.gz: 5803b1fb765174873b3e8f45667b81da60d438d9209ee23d8fb860d391c02b1a6e1fabed9eb6cab14ec5f1d90bf6a37a78ba8edac887a0419ef1efd44f778afa

data/CHANGELOG.md

@@ -3,6 +3,21 @@ 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.2] - 2019-07-24
+### Added
+- Added the `Namespace#create_includes` and `Namespace#create_extends` methods
+to add multiple `include` and `extend` calls at once.
+
+### Changed
+- Signatures for some methods using keyword parameters have been altered such
+that those keywords are required. Previously, these parameters defaulted to
+`nil`, and the Sorbet runtime would fail an assertion if they weren't present.
+
+### Fixed
+- Fixed some incorrect documentation for the `Namespace` methods `path` and
+`create_constant`.
+- Fixed a Sorbet signature for `Method#describe` which was causing an exception.
+
 ## [0.5.1] - 2019-07-21
 ### Added
 - Added the `Namespace#path` method for plugins to use.

data/README.md

@@ -151,6 +151,7 @@ plugins:
 _Have you written an awesome Parlour plugin? Please submit a PR to add it to this list!_
 
   - [Sord](https://github.com/AaronC81/sord) - Generate RBIs from YARD documentation
+  - [parlour-datamapper](https://github.com/AaronC81/parlour-datamapper) - Simple plugin for generating DataMapper model types
 
 
 ## Contributing

data/lib/parlour/plugin.rb

@@ -33,14 +33,19 @@ module Parlour
     #
     # @param plugins [Array<Plugin>] An array of {Plugin} instances.
     # @param generator [RbiGenerator] The {RbiGenerator} to run the plugins on.
+    # @param allow_failure [Boolean] Whether to keep running plugins if a plugin
+    #   throws an exception. If false, the exception is re-raised when caught.
     # @return [void]
-    def self.run_plugins(plugins, generator)
+    def self.run_plugins(plugins, generator, allow_failure: true)
       plugins.each do |plugin|
-        puts "=== #{plugin.class.name}"
-        generator.current_plugin = plugin
-        plugin.generate(generator.root)
-      rescue Exception => e
-        puts "!!! This plugin threw an exception: #{e}"
+        begin
+          puts "=== #{plugin.class.name}"
+          generator.current_plugin = plugin
+          plugin.generate(generator.root)
+        rescue Exception => e
+          raise e unless allow_failure
+          puts "!!! This plugin threw an exception: #{e}"
+        end
       end
     end
 

data/lib/parlour/rbi_generator/method.rb

@@ -185,7 +185,7 @@ module Parlour
         # We don't need to change anything! We only merge identical methods
       end
 
-      sig { override.returns(String) }
+      sig { implementation.returns(String) }
       # Returns a human-readable brief string description of this method.
       #
       # @return [String]

data/lib/parlour/rbi_generator/namespace.rb

@@ -79,12 +79,12 @@ 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
       # @param block A block which the new {Namespace} yields itself to.
-      sig { params(object: T.untyped, block: T.proc.params(x: Namespace).void).void }
       def path(object, &block)
         raise 'only call #path on root' if is_a?(ClassNamespace) || is_a?(ModuleNamespace)
 
@@ -130,7 +130,7 @@ module Parlour
 
       sig do
         params(
-          name: T.nilable(String),
+          name: String,
           superclass: T.nilable(String),
           abstract: T::Boolean,
           block: T.nilable(T.proc.params(x: ClassNamespace).void)
@@ -152,8 +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: nil, superclass: nil, abstract: false, &block)
-        name = T.must(name)
+      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
@@ -162,7 +161,7 @@ module Parlour
 
       sig do
         params(
-          name: T.nilable(String),
+          name: String,
           interface: T::Boolean,
           block: T.nilable(T.proc.params(x: ClassNamespace).void)
         ).returns(ModuleNamespace)
@@ -182,8 +181,7 @@ module Parlour
       #   interface.
       # @param block A block which the new instance yields itself to.
       # @return [ModuleNamespace]
-      def create_module(name: nil, interface: false, &block)
-        name = T.must(name)
+      def create_module(name:, interface: false, &block)
         new_module = ModuleNamespace.new(generator, name, interface, &block)
         move_next_comments(new_module)
         children << new_module
@@ -192,7 +190,7 @@ module Parlour
 
       sig do
         params(
-          name: T.nilable(String),
+          name: String,
           parameters: T.nilable(T::Array[Parameter]),
           return_type: T.nilable(String),
           returns: T.nilable(String),
@@ -223,8 +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: nil, parameters: nil, return_type: nil, returns: nil, abstract: false, implementation: false, override: false, overridable: false, class_method: false, &block)
-        name = T.must(name)
+      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
@@ -269,10 +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: nil, kind: nil, type: nil, &block)
-        name = T.must(name)
-        kind = T.must(kind)
-        type = T.must(type)
+      def create_attribute(name:, kind:, type:, &block)
         new_attribute = RbiGenerator::Attribute.new(
           generator,
           name,
@@ -293,7 +287,7 @@ 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: nil, type: nil, &block)
+      def create_attr_reader(name:, type:, &block)
         create_attribute(name: name, kind: :reader, type: type, &block)
       end
 
@@ -304,7 +298,7 @@ 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: nil, type: nil, &block)
+      def create_attr_writer(name:, type:, &block)
         create_attribute(name: name, kind: :writer, type: type, &block)
       end
 
@@ -315,7 +309,7 @@ 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: nil, type: nil, &block)
+      def create_attr_accessor(name:, type:, &block)
         create_attribute(name: name, kind: :accessor, type: type, &block)
       end
 
@@ -325,8 +319,7 @@ module Parlour
       # @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)
+      def create_arbitrary(code:, &block)
         new_arbitrary = RbiGenerator::Arbitrary.new(
           generator,
           code: code,
@@ -347,8 +340,7 @@ module Parlour
       #   +"MyModule"+.
       # @param block A block which the new instance yields itself to.
       # @return [RbiGenerator::Extend]
-      def create_extend(name: nil, &block)
-        name = T.must(name)
+      def create_extend(name:, &block)
         new_extend = RbiGenerator::Extend.new(
           generator,
           name: name,
@@ -359,18 +351,33 @@ module Parlour
         new_extend
       end
 
+      sig { params(extendables: T::Array[String]).returns(T::Array[Extend]) }
+      # Adds new +extend+s to this namespace.
+      #
+      # @example Add +extend+s to a class.
+      #   class.create_extends(['Foo', 'Bar'])
+      #
+      # @param [Array<String>] extendables An array of names for whatever is being extended.
+      # @return [Array<RbiGenerator::Extend>]
+      def create_extends(extendables)
+        returned_extendables = []
+        extendables.each do |extendable|
+          returned_extendables << create_extend(name: extendable)
+        end
+        returned_extendables
+      end
+
       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.create_include(name:  'IncludableClass') #=> include IncludableClass
+      #   class.create_include(name: 'IncludableClass') #=> include IncludableClass
       #
-      # @param object [String] A code string for what is included, for example
+      # @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: nil, &block)
-        name = T.must(name)
+      def create_include(name:, &block)
         new_include = RbiGenerator::Include.new(
           generator,
           name: name,
@@ -381,19 +388,33 @@ module Parlour
         new_include
       end
 
+      sig { params(includables: T::Array[String]).returns(T::Array[Include]) }
+      # Adds new +include+s to this namespace.
+      #
+      # @example Add +include+s to a class.
+      #   class.create_includes(['Foo', 'Bar'])
+      #
+      # @param [Array<String>] includables An array of names for whatever is being included.
+      # @return [Array<RbiGenerator::Include>]
+      def create_includes(includables)
+        returned_includables = []
+        includables.each do |includable|
+          returned_includables << create_include(name: includable)
+        end
+        returned_includables
+      end
+
       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
+      #   class.create_constant(name: '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: nil, value: nil, &block)
-        name = T.must(name)
-        value = T.must(value)
+      def create_constant(name:, value:, &block)
         new_constant = RbiGenerator::Constant.new(
           generator,
           name: name,

data/lib/parlour/version.rb

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

metadata

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