parlour 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f14e75030cacb5f17788f44b4433f99061f6cf2d33ad809f54e15eeffa345e75
-  data.tar.gz: b68177fc5b69ac579adcc12b06d231fa650beef042f627534f22ebb8effeb0b8
+  metadata.gz: e525051c1791bc175f8cbd109497f058e8708a60820683390e76c0f055ffca32
+  data.tar.gz: 68ff90fd52d6c2b252460b62402556ddee28ac246e7d16f16681e7dcd5e07337
 SHA512:
-  metadata.gz: 69df3cca5b4420140ba5a45c563f51d26ed3043a67ea2128ef75775e8abc510fb5981d7282a0a437aa7ddcf36031950e1d32342ebf56e5ffca136480db319521
-  data.tar.gz: 252dd6eabe1bd8deadc1ecea1e20e60793ee180eb2e5211ac622919a24bacb0597e6ef4599d7b2b77a446d1c31f5c0c182ccb8221812a2e3ec17e8ed48e34540
+  metadata.gz: f677a46f79678ae034348c85e52fbe80ee231eadb9ab08544fef93970f7a3615d0edc79aabeaa6b0be47072394054896d8f09e4b93a11c69e8caa13f6e7a25d2
+  data.tar.gz: fa81cba64780ff57a8b147b6aeb5b6501f3fbc6bfbf877480f017ca4a0f8cd989992067416f5afc326293d2f83a4e1652957576a0425298d60a26ecea934660d

data/.travis.yml

@@ -12,13 +12,16 @@ rvm:
 matrix:
   allow_failures:
     - rvm: ruby-head
-after_success:
-  - yard
-deploy:
-  provider: pages
-  local_dir: doc
-  skip_cleanup: true
-  github_token: $GITHUB_TOKEN
-  keep_history: true
-  on:
-    branch: master
+
+jobs:
+  include:
+    - stage: deploy documentation
+      script: yard
+      deploy:
+        provider: pages
+        local_dir: doc
+        skip_cleanup: true
+        github_token: $GITHUB_TOKEN
+        keep_history: true
+        on:
+          branch: master

data/CHANGELOG.md

@@ -3,6 +3,29 @@ 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.7.0] - 2019-09-11
+### Added
+- The strictness level can now be specified when generating an RBI, using an
+optional positional argument to `RBIGenerator#generate`. The default strictness
+is `strong`.
+- Plugins can specify a strictness level they would prefer by setting
+`Plugin#strictness` for themselves. If multiple plugins set conflicting 
+strictnesses, the least strict will be used.
+- Attributes can now specified as class attributes by setting
+`Attribute#class_attribute` to `true`. This will wrap them in a `class << self`
+block.
+
+### Changed
+- The `sorbet` directory is no longer included in the built gem.
+- Generated files now end with a new line (`\n`).
+
+### Fixed
+- An instance method and a class method with the same name are no longer
+considered conflicting.
+- The signature for the constructor of `Attribute` previously typed the optional
+initializer block as taking a `Method`. This has been corrected to taking an
+`Attribute`.
+
 ## [0.6.1] - 2019-07-29
 ### Changed
 - Various areas of the codebase have been made compatible with older Ruby

data/README.md

@@ -158,6 +158,13 @@ _Have you written an awesome Parlour plugin? Please submit a PR to add it to thi
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/AaronC81/parlour. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
+After making changes, you may wish to regenerate the RBI definitions in the `sorbet` folder by running these `srb rbi` commands:
+
+```
+srb rbi gems
+srb rbi sorbet-typed
+```
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/exe/parlour

@@ -71,9 +71,32 @@ command :run do |c|
       choice = ask("?  ", Integer) { |q| q.in = 0..candidates.length }
       choice == 0 ? nil : candidates[choice - 1]
     end
+
+    # Figure out strictness levels
+    requested_strictness_levels = plugin_instances.map do |plugin|
+      s = plugin.strictness&.to_s
+      puts "WARNING: Plugin #{plugin.class.name} requested an invalid strictness #{s}" \
+        unless s && %w[ignore false true strict strong].include?(s)
+      s
+    end.compact
+    unique_strictness_levels = requested_strictness_levels.uniq
+    if unique_strictness_levels.empty?
+      # If no requests were made, just use the default
+      strictness = 'strong' 
+    else
+      # Sort the strictnesses into "strictness order" and pick the weakest
+      strictness = unique_strictness_levels.min_by do |level|
+        %w[ignore false true strict strong].index(level) || Float::INFINITY
+      end
+      if unique_strictness_levels.one?
+        puts Rainbow('Note: ').yellow.bold + "All plugins specified the same strictness level, using it (#{strictness})"
+      else
+        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)
+    File.write(configuration[:output_file], gen.rbi(strictness))
   end
 end
 

data/lib/parlour/conflict_resolver.rb

@@ -44,6 +44,18 @@ module Parlour
 
       grouped_by_name_children.each do |name, children|
         if children.length > 1
+          # Special case: do we have two methods, one of which is a class method 
+          # and the other isn't? If so, do nothing - this is fine
+          next if children.length == 2 &&
+            children.all? { |c| c.is_a?(RbiGenerator::Method) } &&
+            children.count { |c| T.cast(c, RbiGenerator::Method).class_method } == 1
+
+          # Special case: do we have two attributes, one of which is a class 
+          # attribute and the other isn't? If so, do nothing - this is fine
+          next if children.length == 2 &&
+            children.all? { |c| c.is_a?(RbiGenerator::Attribute) } &&
+            children.count { |c| T.cast(c, RbiGenerator::Attribute).class_attribute } == 1
+
           # We found a conflict!
           # Start by removing all the conflicting items
           children.each do |c|

data/lib/parlour/plugin.rb

@@ -60,5 +60,12 @@ module Parlour
     # @param root [RbiGenerator::Namespace] The root {RbiGenerator::Namespace}.
     # @return [void]
     def generate(root); end
+
+    sig { returns(T.nilable(String)) }
+    # The strictness level which this plugin would prefer the generated RBI
+    # uses. If other plugins request different strictness levels, then the 
+    # lowest strictness will be used, meaning there is no guarantee that this
+    # level will be used.
+    attr_accessor :strictness
   end
 end

data/lib/parlour/rbi_generator.rb

@@ -38,12 +38,12 @@ module Parlour
     # @return [Plugin, nil]
     attr_accessor :current_plugin
 
-    sig { returns(String) }
+    sig { params(strictness: String).returns(String) }
     # Returns the complete contents of the generated RBI file as a string.
     #
     # @return [String] The generated RBI file
-    def rbi
-      "# typed: strong\n" + root.generate_rbi(0, options).join("\n")
+    def rbi(strictness = 'strong')
+      "# typed: #{strictness}\n" + root.generate_rbi(0, options).join("\n") + "\n"
     end
   end
 end

data/lib/parlour/rbi_generator/attribute.rb

@@ -9,7 +9,8 @@ module Parlour
           name: String,
           kind: Symbol,
           type: String,
-          block: T.nilable(T.proc.params(x: Method).void)
+          class_attribute: T::Boolean,
+          block: T.nilable(T.proc.params(x: Attribute).void)
         ).void
       end
       # Creates a new attribute.
@@ -21,15 +22,18 @@ module Parlour
       #   :accessor.
       # @param type [String] A Sorbet string of this attribute's type, such as
       #   +"String"+ or +"T.untyped"+.
+      # @param class_attribute [Boolean] Whether this attribute belongs to the
+      #   singleton class.
       # @param block A block which the new instance yields itself to.
       # @return [void]
-      def initialize(generator, name, kind, type, &block)
+      def initialize(generator, name, kind, type, class_attribute: false, &block)
         # According to this source: 
         #   https://github.com/sorbet/sorbet/blob/2275752e51604acfb79b30a0a96debc996c089d9/test/testdata/dsl/attr_multi.rb
         # attr_accessor and attr_reader should have: sig { returns(X) }
         # attr_writer :foo should have: sig { params(foo: X).returns(X) }
 
         @kind = kind
+        @class_attribute = class_attribute
         case kind
         when :accessor, :reader
           super(generator, name, [], type, &block)
@@ -47,6 +51,24 @@ module Parlour
       # @return [Symbol]
       attr_reader :kind
 
+      sig { returns(T::Boolean) }
+      # Whether this attribute belongs to the singleton class.
+      attr_reader :class_attribute
+
+      sig { override.params(other: Object).returns(T::Boolean) }
+      # Returns true if this instance is equal to another attribute.
+      #
+      # @param other [Object] The other instance. If this is not a {Attribute}
+      #   (or a subclass of it), this will always return false.
+      # @return [Boolean]
+      def ==(other)
+        T.must(
+          super(other) && Attribute === other &&
+            kind            == other.kind &&
+            class_attribute == other.class_attribute
+        )
+      end
+
       private
 
       sig do

data/lib/parlour/rbi_generator/method.rb

@@ -51,7 +51,7 @@ module Parlour
         yield_self(&block) if block
       end
 
-      sig { params(other: Object).returns(T::Boolean) }
+      sig { overridable.params(other: Object).returns(T::Boolean) }
       # Returns true if this instance is equal to another method.
       #
       # @param other [Object] The other instance. If this is not a {Method} (or a

data/lib/parlour/rbi_generator/namespace.rb

@@ -242,36 +242,55 @@ module Parlour
         new_method
       end
 
+      sig do
+        params(
+          name: String,
+          kind: Symbol,
+          type: String,
+          class_attribute: T::Boolean,
+          block: T.nilable(T.proc.params(x: Attribute).void)
+        ).returns(Attribute)
+      end
       # Creates a new attribute.
       #
       # @example Create an +attr_reader+.
-      #   module.create_attribute('readable', :reader, 'String')
+      #   module.create_attribute('readable', kind: :reader, type: 'String')
       #   # #=> sig { returns(String) }
       #   #     attr_reader :readable
       #
       # @example Create an +attr_writer+.
-      #   module.create_attribute('writable', :writer, 'Integer')
+      #   module.create_attribute('writable', kind: :writer, type: 'Integer')
       #   # #=> sig { params(writable: Integer).returns(Integer) }
       #   #     attr_writer :writable
       #
       # @example Create an +attr_accessor+.
-      #   module.create_attribute('accessible', :accessor, 'T::Boolean')
+      #   module.create_attribute('accessible', kind: :accessor, type: 'T::Boolean')
       #   # #=> sig { returns(T::Boolean) }
       #   #     attr_accessor :accessible
       #
+      # @example Create an +attr_accessor+ on the singleton class.
+      #   module.create_attribute('singleton_attr', kind: :accessor, type: 'T::Boolean')
+      #   # #=> class << self
+      #   #       sig { returns(T::Boolean) }
+      #   #       attr_accessor :singleton_attr
+      #   #     end
+      #
       # @param name [String] The name of this attribute.
       # @param kind [Symbol] The kind of attribute this is; one of +:writer+, +:reader+, or
       #   +:accessor+.
       # @param type [String] A Sorbet string of this attribute's type, such as
       #   +"String"+ or +"T.untyped"+.
+      # @param class_attribute [Boolean] Whether this attribute belongs to the
+      #   singleton class.
       # @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:, class_attribute: false, &block)
         new_attribute = RbiGenerator::Attribute.new(
           generator,
           name,
           kind,
           type,
+          class_attribute: class_attribute,
           &block
         )
         move_next_comments(new_attribute)
@@ -280,37 +299,67 @@ module Parlour
       end
       alias_method :create_attr, :create_attribute
 
+      sig do
+        params(
+          name: String,
+          type: String,
+          class_attribute: T::Boolean,
+          block: T.nilable(T.proc.params(x: Attribute).void)
+        ).returns(Attribute)
+      end
       # Creates a new read-only attribute (+attr_reader+).
       #
       # @param name [String] The name of this attribute.
       # @param type [String] A Sorbet string of this attribute's type, such as
       #   +"String"+ or +"T.untyped"+.
+      # @param class_attribute [Boolean] Whether this attribute belongs to the
+      #   singleton class.
       # @param block A block which the new instance yields itself to.
       # @return [RbiGenerator::Attribute]
-      def create_attr_reader(name, type:, &block)
-        create_attribute(name, kind: :reader, type: type, &block)
+      def create_attr_reader(name, type:, class_attribute: false, &block)
+        create_attribute(name, kind: :reader, type: type, class_attribute: class_attribute, &block)
       end
 
+      sig do
+        params(
+          name: String,
+          type: String,
+          class_attribute: T::Boolean,
+          block: T.nilable(T.proc.params(x: Attribute).void)
+        ).returns(Attribute)
+      end
       # Creates a new write-only attribute (+attr_writer+).
       #
       # @param name [String] The name of this attribute.
       # @param type [String] A Sorbet string of this attribute's type, such as
       #   +"String"+ or +"T.untyped"+.
+      # @param class_attribute [Boolean] Whether this attribute belongs to the
+      #   singleton class.
       # @param block A block which the new instance yields itself to.
       # @return [RbiGenerator::Attribute]
-      def create_attr_writer(name, type:, &block)
-        create_attribute(name, kind: :writer, type: type, &block)
+      def create_attr_writer(name, type:, class_attribute: false, &block)
+        create_attribute(name, kind: :writer, type: type, class_attribute: class_attribute, &block)
       end
 
+      sig do
+        params(
+          name: String,
+          type: String,
+          class_attribute: T::Boolean,
+          block: T.nilable(T.proc.params(x: Attribute).void)
+        ).returns(Attribute)
+      end
       # Creates a new read and write attribute (+attr_accessor+).
       #
       # @param name [String] The name of this attribute.
       # @param type [String] A Sorbet string of this attribute's type, such as
       #   +"String"+ or +"T.untyped"+.
+      # @param class_attribute [Boolean] Whether this attribute belongs to the
+      #   singleton class.
       # @param block A block which the new instance yields itself to.
       # @return [RbiGenerator::Attribute]
-      def create_attr_accessor(name, type:, &block)
-        create_attribute(name, kind: :accessor, type: type, &block)
+      def create_attr_accessor(name, type:, class_attribute: false, &block)
+        create_attribute(name, kind: :accessor, type: type, class_attribute: class_attribute, &block)
       end
 
       # Creates a new arbitrary code section.
@@ -501,13 +550,29 @@ module Parlour
           result << ""
         end
 
-        first, *rest = children.reject do |child|
+        # Process singleton class attributes
+        class_attributes, remaining_children = children.partition do |child|
+          child.is_a?(Attribute) && child.class_attribute
+        end
+        if class_attributes.any?
+          result << options.indented(indent_level, 'class << self')
+
+          first, *rest = class_attributes
+          result += T.must(first).generate_rbi(indent_level + 1, options) + T.must(rest)
+            .map { |obj| obj.generate_rbi(indent_level + 1, options) }
+            .map { |lines| [""] + lines }
+            .flatten
+          result << options.indented(indent_level, 'end')
+          result << ''
+        end
+
+        first, *rest = remaining_children.reject do |child|
           # We already processed these kinds of children
           child.is_a?(Include) || child.is_a?(Extend) || child.is_a?(Constant)
         end
         unless first
-          # Remove any trailing whitespace due to includes
-          result.pop if result.last == ''
+          # Remove any trailing whitespace due to includes or class attributes
+          result.pop while result.last == ''
           return result
         end
 

data/lib/parlour/version.rb

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

data/parlour.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|sorbet)/}) }
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parlour
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Aaron Christiansen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-07-29 00:00:00.000000000 Z
+date: 2019-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -148,16 +148,6 @@ files:
 - lib/parlour/version.rb
 - parlour.gemspec
 - plugin_examples/foobar_plugin.rb
-- sorbet/config
-- sorbet/rbi/gems/rake.rbi
-- sorbet/rbi/gems/rspec-core.rbi
-- sorbet/rbi/gems/rspec-support.rbi
-- sorbet/rbi/gems/rspec.rbi
-- sorbet/rbi/hidden-definitions/errors.txt
-- sorbet/rbi/hidden-definitions/hidden.rbi
-- sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi
-- sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi
-- sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi
 homepage: https://github.com/AaronC81/parlour
 licenses:
 - MIT
@@ -177,7 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: An RBI generator