parlour 2.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 889d6730ffefc764887706e5dadc4441e66cdf32e4567e809f7e634f511b7dfc
-  data.tar.gz: 9e9ab14b6618c209c8d194bf6e5557398689f0656247cac9561064dbcd541a6a
+  metadata.gz: 1e2b9021c22592632f30a0a51c17cfbf3838c18061638297e9437c1dd34b5c9f
+  data.tar.gz: 337e2ea6d8212e6c2d16d2f8f5577b16bfd1c8ffa41197fad70f9dc7c51620b5
 SHA512:
-  metadata.gz: ea57b34b827ced92fdd1d28387217c0a5bc7027d94319cac6ffb238847a2820e9c164df86c9b2c43e60826cb1b362000c7c2bfc7f1f63b9b998959c70a3be377
-  data.tar.gz: fb10c8c783aea69e412d1a6eb67dd736f3db377168a21f8025e28fdb76acfc94ed20f1f7b9a17dafbac39ebcc2d36846b350d04c3e59882b546143df374b9f41
+  metadata.gz: 22e0196918f8214827f9904e45fff8689f4609ec71683ad4aca36c8eb75593e19f5d0ec4e5a5e034afdca1d3bdf7f0d9482bfb24b0e3e667553c13b5cb5b65a6
+  data.tar.gz: 2b322d3dcdce74985b2104a8d8beb8ac0a7b6b4de1bcc8af7288d5334d715765285cba032017c7ab6e5dccde045b284dd8056e57515e13f32f319de26fdc0666

data/.travis.yml

@@ -10,10 +10,6 @@ rvm:
   - 2.6
   - 2.7
   - ruby-head
-matrix:
-  allow_failures:
-    - rvm: 2.3
-    - rvm: ruby-head
 
 jobs:
   include:
@@ -27,3 +23,6 @@ jobs:
         keep_history: true
         on:
           branch: master
+  allow_failures:
+    - rvm: 2.3
+    - rvm: ruby-head

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/).
 
+## [3.0.0] - 2020-05-15
+### Added
+- `T::Struct` classes can now be generated and parsed.
+- `T::Enum` classes can now be parsed.
+- Constants are now parsed.
+- `TypeParser` now detects and parses methods which do not have a `sig`.
+  **Potentially breaking if there is a strict set of methods you are expecting Parlour to detect.**
+
+### Fixed
+- "Specialized" classes, such as enums and now structs, have had many erroneous
+  conflicts with standard classes or namespaces fixed.
+- Attributes writers and methods with the same name no longer conflict incorrectly.
+
 ## [2.1.0] - 2020-03-22
 ### Added
 - Files can now be excluded from the `TypeLoader`.

data/lib/parlour.rb

@@ -22,6 +22,8 @@ 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/struct_prop'
+require 'parlour/rbi_generator/struct_class_namespace'
 require 'parlour/rbi_generator'
 require 'parlour/detached_rbi_generator'
 

data/lib/parlour/conflict_resolver.rb

@@ -1,4 +1,6 @@
 # typed: true
+require 'set'
+
 module Parlour
   # Responsible for resolving conflicts (that is, multiple definitions with the
   # same name) between objects defined in the same namespace.
@@ -42,8 +44,15 @@ module Parlour
       Debugging.debug_puts(self, Debugging::Tree.begin("Resolving conflicts for #{namespace.name}..."))
 
       # Check for multiple definitions with the same name
-      grouped_by_name_children = namespace.children.group_by(&:name)
-
+      # (Special case here: writer attributes get an "=" appended to their name)
+      grouped_by_name_children = namespace.children.group_by do |child|
+        if RbiGenerator::Attribute === child && child.kind == :writer
+          "#{child.name}=" unless child.name.end_with?('=')
+        else
+          child.name
+        end
+      end
+      
       grouped_by_name_children.each do |name, children|
         Debugging.debug_puts(self, Debugging::Tree.begin("Checking children named #{name}..."))
 
@@ -60,6 +69,20 @@ module Parlour
             next
           end
 
+          # Special case: if we remove the namespaces, is everything either an
+          # include or an extend? If so, do nothing - this is fine
+          if children \
+            .reject { |c| c.is_a?(RbiGenerator::Namespace) }
+            .then do |x|
+              !x.empty? && x.all? do |c|
+                c.is_a?(RbiGenerator::Include) || c.is_a?(RbiGenerator::Extend)
+              end
+            end
+            
+            Debugging.debug_puts(self, Debugging::Tree.end("Includes/extends do not conflict with namespaces; no resolution required"))
+            next
+          end
+
           # 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
           if children.length == 2 &&
@@ -117,14 +140,25 @@ module Parlour
                 choice = resolver.call("Non-namespace item in a differing namespace conflict is not a single method", non_namespaces)
                 non_namespaces = []
                 non_namespaces << choice if choice
-              end 
+              end
             end
 
             non_namespaces.each do |x|
               namespace.children << x
             end
 
-            first, *rest = namespaces
+            # For certain namespace types the order matters. For example, if there's
+            # both a `Namespace` and `ModuleNamespace` then merging the two would
+            # produce different results depending on which is first.
+            first_index = (
+              namespaces.find_index { |x| RbiGenerator::EnumClassNamespace === x || RbiGenerator::StructClassNamespace === x } ||
+              namespaces.find_index { |x| RbiGenerator::ClassNamespace === x } ||
+              namespaces.find_index { |x| RbiGenerator::ModuleNamespace === x } ||
+              0
+            )
+
+            first = namespaces.delete_at(first_index)
+            rest = namespaces
           else
             raise 'unknown merge strategy; this is a Parlour bug'
           end
@@ -161,16 +195,16 @@ module Parlour
 
     sig { params(arr: T::Array[T.untyped]).returns(T.nilable(Symbol)) }
     # Given an array, if all elements in the array are instances of the exact
-    # same class or are otherwise mergeable (for example Namespace and 
+    # same class or are otherwise mergeable (for example Namespace and
     # ClassNamespace), returns the kind of merge which needs to be made. A
     # return value of nil indicates that the values cannot be merged.
     #
     # The following kinds are available:
     #   - They are all the same. (:normal)
-    #   - There are exactly two types, one of which is Namespace and other is a 
+    #   - There are exactly two types, one of which is Namespace and other is a
     #     subclass of it. (:differing_namespaces)
     #   - One of them is Namespace or a subclass (or both, as described above),
-    #     and the only other is Method. (also :differing_namespaces) 
+    #     and the only other is Method. (also :differing_namespaces)
     #
     # @param arr [Array] The array.
     # @return [Symbol] The merge strategy to use, or nil if they can't be
@@ -182,21 +216,13 @@ module Parlour
 
       # Find all the namespaces and non-namespaces
       namespace_types, non_namespace_types = array_types.partition { |x| x <= RbiGenerator::Namespace }
+      exactly_namespace, namespace_subclasses = namespace_types.partition { |x| x == RbiGenerator::Namespace }
+
+      return nil unless namespace_subclasses.empty? \
+        || (namespace_subclasses.length == 1 && namespace_subclasses.first < RbiGenerator::Namespace) \
+        || namespace_subclasses.to_set == Set[RbiGenerator::ClassNamespace, RbiGenerator::StructClassNamespace] \
+        || namespace_subclasses.to_set == Set[RbiGenerator::ClassNamespace, RbiGenerator::EnumClassNamespace]
 
-      # If there are two namespace types, one should be Namespace and the other
-      # should be a subclass of it
-      if namespace_types.length == 2
-        exactly_namespace, exactly_one_subclass = namespace_types.partition { |x| x == RbiGenerator::Namespace }
-
-        return nil unless exactly_namespace.length == 1 \
-          && exactly_one_subclass.length == 1 \
-          && exactly_one_subclass.first < RbiGenerator::Namespace
-      elsif namespace_types.length != 1
-        # The only other valid number of namespaces is 1, where we don't need to
-        # check anything
-        return nil
-      end
-      
       # It's OK, albeit cursed, for there to be a method with the same name as
       # a namespace (Rainbow does this)
       return nil if non_namespace_types.length != 0 && non_namespace_types != [RbiGenerator::Method]

data/lib/parlour/rbi_generator/enum_class_namespace.rb

@@ -80,10 +80,32 @@ module Parlour
       # @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)
+        others = T.cast(others, T::Array[Namespace]) rescue (return false)
         all = others + [self]
+        all_enums = T.cast(all.select { |x| EnumClassNamespace === x }, T::Array[EnumClassNamespace])
 
-        T.must(super && all.map(&:enums).uniq.length <= 1)
+        T.must(super && all_enums.map { |e| e.enums.sort }.reject(&:empty?).uniq.length <= 1)
+      end
+
+      sig do
+        override.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).void
+      end
+      # Given an array of {EnumClassNamespace} instances, merges them into this one.
+      # You MUST ensure that {mergeable?} is true for those instances.
+      #
+      # @param others [Array<RbiGenerator::RbiObject>] An array of other {EnumClassNamespace} instances.
+      # @return [void]
+      def merge_into_self(others)
+        super
+
+        others.each do |other|
+          next unless EnumClassNamespace === other
+          other = T.cast(other, EnumClassNamespace)
+
+          @enums = other.enums if enums.empty?
+        end
       end
     end
   end

data/lib/parlour/rbi_generator/namespace.rb

@@ -196,6 +196,35 @@ module Parlour
         new_enum_class
       end
 
+      sig do
+        params(
+          name: String,
+          final: T::Boolean,
+          props: T.nilable(T::Array[StructProp]),
+          abstract: T::Boolean,
+          block: T.nilable(T.proc.params(x: StructClassNamespace).void)
+        ).returns(StructClassNamespace)
+      end
+      # Creates a new struct class definition as a child of this namespace.
+      #
+      # @example Create a person struct.
+      #   namespace.create_class('Person', props: [
+      #     Parlour::RbiGenerator::StructProp.new('name', 'String')
+      #   ])
+      #
+      # @param name [String] The name of this class.
+      # @param final [Boolean] Whether this namespace is final.
+      # @param props [Array<StructProp>] The props of the struct.
+      # @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_struct_class(name, final: false, props: nil, abstract: false, &block)
+        new_struct_class = StructClassNamespace.new(generator, name, final, props || [], abstract, &block)
+        move_next_comments(new_struct_class)
+        children << new_struct_class
+        new_struct_class
+      end
+
       sig do
         params(
           name: String,

data/lib/parlour/rbi_generator/struct_class_namespace.rb

@@ -0,0 +1,103 @@
+# typed: true
+module Parlour
+  class RbiGenerator
+    # Represents an struct definition; that is, a class which subclasses
+    # +T::Struct+ and declares `prop` members.
+    class StructClassNamespace < ClassNamespace
+      extend T::Sig
+
+      sig do
+        params(
+          generator: RbiGenerator,
+          name: String,
+          final: T::Boolean,
+          props: T::Array[StructProp],
+          abstract: T::Boolean,
+          block: T.nilable(T.proc.params(x: StructClassNamespace).void)
+        ).void
+      end
+      # Creates a new struct class definition.
+      # @note You should use {Namespace#create_struct_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 props [Array<StructProp>] The props of the struct.
+      # @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, props, abstract, &block)
+        super(generator, name, final, 'T::Struct', abstract, &block)
+        @props = props
+      end
+
+      sig { returns(T::Array[StructProp]) }
+      # The props of the struct.
+      # @return [Array<StructProp>]
+      attr_reader :props
+
+      sig do
+        override.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      # Generates the RBI lines for the body of this struct. This consists of
+      # {props}, {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 = []
+        props.each do |prop|
+          result << options.indented(indent_level, prop.to_prop_call)
+        end
+        result << ''
+
+        result + super
+      end
+
+      sig do
+        override.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).returns(T::Boolean)
+      end
+      # Given an array of {StructClassNamespace} 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 {StructClassNamespace} instances.
+      # @return [Boolean] Whether this instance may be merged with them.
+      def mergeable?(others)
+        others = T.cast(others, T::Array[Namespace]) rescue (return false)
+        all = others + [self]
+        all_structs = T.cast(all.select { |x| StructClassNamespace === x }, T::Array[StructClassNamespace])
+
+        T.must(super && all_structs.map { |s| s.props.map(&:to_prop_call).sort }.reject(&:empty?).uniq.length <= 1)
+      end
+
+      sig do
+        override.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).void
+      end
+      # Given an array of {StructClassNamespace} instances, merges them into this one.
+      # You MUST ensure that {mergeable?} is true for those instances.
+      #
+      # @param others [Array<RbiGenerator::RbiObject>] An array of other {StructClassNamespace} instances.
+      # @return [void]
+      def merge_into_self(others)
+        super
+
+        others.each do |other|
+          next unless StructClassNamespace === other
+          other = T.cast(other, StructClassNamespace)
+
+          @props = other.props if props.empty?
+        end
+      end
+    end
+  end
+end

data/lib/parlour/rbi_generator/struct_prop.rb

@@ -0,0 +1,136 @@
+# typed: true
+module Parlour
+  class RbiGenerator
+    # Represents a +T::Struct+ property.
+    class StructProp
+      extend T::Sig
+
+      sig do
+        params(
+          name: String,
+          type: String,
+          optional: T.nilable(T.any(T::Boolean, Symbol)),
+          enum: T.nilable(String),
+          dont_store: T.nilable(T::Boolean),
+          foreign: T.nilable(String),
+          default: T.nilable(String),
+          factory: T.nilable(String),
+          immutable: T.nilable(T::Boolean),
+          array: T.nilable(String),
+          override: T.nilable(T::Boolean),
+          redaction: T.nilable(String),
+        ).void
+      end
+      # Create a new struct property.
+      #
+      # For documentation on all optional properties, please refer to the
+      # documentation for T::Struct within the sorbet-runtime gem:
+      # https://github.com/sorbet/sorbet/blob/master/gems/sorbet-runtime/lib/types/props/_props.rb#L31-L106
+      #
+      # @param name [String] The name of this property.
+      # @param type [String] A Sorbet string of this property's type, such as
+      #   +"String"+.
+      # @return [void]
+      def initialize(name, type, optional: nil, enum: nil, dont_store: nil,
+        foreign: nil, default: nil, factory: nil, immutable: nil, array: nil,
+        override: nil, redaction: nil)
+        
+        @name = name
+        @type = type
+        @optional = optional
+        @enum = enum
+        @dont_store = dont_store
+        @foreign = foreign
+        @default = default
+        @factory = factory
+        @immutable = immutable
+        @array = array
+        @override = override
+        @redaction = redaction
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      # Returns true if this instance is equal to another instance.
+      #
+      # @param other [Object] The other instance. If this is not a {StructProp} (or a
+      #   subclass of it), this will always return false.
+      # @return [Boolean]
+      def ==(other)
+        StructProp === other &&
+          name       == other.name &&
+          type       == other.type &&
+          optional   == other.optional &&
+          enum       == other.enum &&
+          dont_store == other.dont_store &&
+          foreign    == other.foreign &&
+          default    == other.default &&
+          factory    == other.factory &&
+          immutable  == other.immutable &&
+          array      == other.array &&
+          override   == other.override &&
+          redaction  == other.redaction
+      end
+
+      sig { returns(String) }
+      # The name of this parameter, including any prefixes or suffixes such as
+      # +*+.
+      # @return [String]
+      attr_reader :name
+
+      sig { returns(T.nilable(String)) }
+      # A Sorbet string of this parameter's type, such as +"String"+ or
+      # +"T.untyped"+.
+      # @return [String, nil]
+      attr_reader :type
+
+      sig { returns(T.nilable(T.any(T::Boolean, Symbol))) }
+      attr_reader :optional
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :enum
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :dont_store
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :foreign
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :default
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :factory
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :immutable
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :array
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :override
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :redaction
+
+      # The optional properties available on instances of this class.
+      EXTRA_PROPERTIES = %i{
+        optional enum dont_store foreign default factory immutable array override redaction
+      }
+
+      sig { returns(String) }
+      # Returns the +prop+ call required to create this property.
+      # @return [String]
+      def to_prop_call
+        call = "prop :#{name}, #{type}"
+
+        EXTRA_PROPERTIES.each do |extra_property|
+          value = send extra_property
+          call += ", #{extra_property}: #{value}" unless value.nil?
+        end
+
+        call
+      end
+    end
+  end
+end

data/lib/parlour/type_parser.rb

@@ -108,7 +108,9 @@ module Parlour
       buffer = Parser::Source::Buffer.new(filename)
       buffer.source = source
 
-      TypeParser.new(Parser::CurrentRuby.new.parse(buffer))
+      # || special case handles parser returning nil on an empty file
+      parsed = Parser::CurrentRuby.new.parse(buffer) || Parser::AST::Node.new(:body)
+      TypeParser.new(parsed)
     end
 
     sig { returns(Parser::AST::Node) }
@@ -169,18 +171,103 @@ module Parlour
           top_level ||= new_obj
         end if parent_names
 
-        final_obj = RbiGenerator::ClassNamespace.new(
-          DetachedRbiGenerator.new,
-          this_name.to_s,
-          final,
-          node_to_s(superclass),
-          abstract,
-        ) do |c|
-          c.children.concat(parse_path_to_object(path.child(2))) if body
-          c.create_includes(includes)
-          c.create_extends(extends)
+        # Instantiate the correct kind of class
+        if ['T::Struct', '::T::Struct'].include?(node_to_s(superclass))
+          # Find all of this struct's props and consts
+          # The body is typically a `begin` element but when there's only
+          # one node there's no wrapping block and instead it would directly
+          # be the node.
+          prop_nodes = body.nil? ? [] :
+            (body.type == :begin ? body.to_a : [body]).select { |x| x.type == :send && [:prop, :const].include?(x.to_a[1]) }
+
+          props = prop_nodes.map do |prop_node|
+            _, prop_type, name_node, type_node, extras_hash_node = *prop_node
+
+            # "const" is just "prop ..., immutable: true"
+            extras_hash = extras_hash_node.to_a.map do |pair_node|
+              key_node, value_node = *pair_node
+              parse_err 'prop/const key must be a symbol', prop_node unless key_node.type == :sym
+              key = key_node.to_a.first
+
+              value =
+                if key == :default
+                  T.must(node_to_s(value_node))
+                else
+                  case value_node.type
+                  when :true
+                    true
+                  when :false
+                    false
+                  when :sym
+                    value_node.to_a.first
+                  else
+                    T.must(node_to_s(value_node))
+                  end
+                end
+
+              [key, value]
+            end.to_h
+
+            if prop_type == :const
+              parse_err 'const cannot use immutable key', prop_node unless extras_hash[:immutable].nil?
+              extras_hash[:immutable] = true
+            end
+
+            # Get prop/const name
+            parse_err 'prop/const name must be a symbol or string', prop_node unless [:sym, :str].include?(name_node.type)
+            name = name_node.to_a.first.to_s
+
+            RbiGenerator::StructProp.new(
+              name,
+              T.must(node_to_s(type_node)),
+              **T.unsafe(extras_hash)
+            )
+          end
+
+          final_obj = RbiGenerator::StructClassNamespace.new(
+            DetachedRbiGenerator.new,
+            this_name.to_s,
+            final,
+            props,
+            abstract,
+          )
+        elsif ['T::Enum', '::T::Enum'].include?(node_to_s(superclass))
+          # Look for (block (send nil :enums) ...) structure
+          enums_node = body.nil? ? nil :
+            (body.type == :begin ? body.to_a : [body]).find { |x| x.type == :block && x.to_a[0].type == :send && x.to_a[0].to_a[1] == :enums }
+
+          # Find the constant assigments within this block
+          constant_nodes = enums_node.to_a[2].to_a
+
+          # Convert this to an array to enums as EnumClassNamespace expects
+          enums = constant_nodes.map do |constant_node|
+            _, name, new_node = *constant_node
+            serialize_value = node_to_s(new_node.to_a[2])
+
+            serialize_value ? [name.to_s, serialize_value] : name.to_s
+          end
+
+          final_obj = RbiGenerator::EnumClassNamespace.new(
+            DetachedRbiGenerator.new,
+            this_name.to_s,
+            final,
+            enums,
+            abstract,
+          )
+        else
+          final_obj = RbiGenerator::ClassNamespace.new(
+            DetachedRbiGenerator.new,
+            this_name.to_s,
+            final,
+            node_to_s(superclass),
+            abstract,
+          )
         end
 
+        final_obj.children.concat(parse_path_to_object(path.child(2))) if body
+        final_obj.create_includes(includes)
+        final_obj.create_extends(extends)
+
         if target
           target.children << final_obj
           [top_level]
@@ -230,16 +317,19 @@ module Parlour
       when :send, :block
         if sig_node?(node)
           parse_sig_into_methods(path, is_within_eigenclass: is_within_eigenclass)
+        elsif node.type == :send &&
+            [:attr_reader, :attr_writer, :attr_accessor].include?(node.to_a[1]) &&
+            !previous_sibling_sig_node?(path)
+          parse_method_into_methods(path, is_within_eigenclass: is_within_eigenclass)
         else
           []
         end
       when :def, :defs
-        # TODO: Support for defs without sigs
-        #   If so, we need some kind of state machine to determine whether
-        #   they've already been dealt with by the "when :send" clause and
-        #   #parse_sig_into_methods.
-        #   If not, just ignore this.
-        []
+        if previous_sibling_sig_node?(path)
+          []
+        else
+          parse_method_into_methods(path, is_within_eigenclass: is_within_eigenclass)
+        end
       when :sclass
         parse_err 'cannot access eigen of non-self object', node unless node.to_a[0].type == :self
         parse_path_to_object(path.child(1), is_within_eigenclass: true)
@@ -248,6 +338,13 @@ module Parlour
         node.to_a.length.times.map do |c|
           parse_path_to_object(path.child(c), is_within_eigenclass: is_within_eigenclass)
         end.flatten
+      when :casgn
+        _, name, body = *node
+        [Parlour::RbiGenerator::Constant.new(
+          DetachedRbiGenerator.new,
+          name: T.must(name).to_s,
+          value: T.must(node_to_s(body)),
+        )]
       else
         if unknown_node_errors
           parse_err "don't understand node type #{node.type}", node
@@ -490,6 +587,110 @@ module Parlour
       end
     end
 
+    sig { params(path: NodePath, is_within_eigenclass: T::Boolean).returns(T::Array[RbiGenerator::Method]) }
+    # Given a path to a method in the AST, finds the associated definition and
+    # parses them into methods.
+    # Usually this will return one method; the only exception currently is for
+    # attributes, where multiple can be declared in one call, e.g.
+    # +attr_reader :x, :y, :z+.
+    #
+    # @param [NodePath] path The sig to parse.
+    # @param [Boolean] is_within_eigenclass Whether the method definition this sig is
+    #   associated with appears inside an eigenclass definition. If true, the
+    #   returned method is made a class method. If the method definition
+    #   is already a class method, an exception is thrown as the method will be
+    #   a class method of the eigenclass, which Parlour can't represent.
+    # @return [<RbiGenerator::Method>] The parsed methods.
+    def parse_method_into_methods(path, is_within_eigenclass: false)
+      # A :def node represents a definition like "def x; end"
+      # A :defs node represents a definition like "def self.x; end"
+      def_node = path.traverse(ast)
+      case def_node.type
+      when :def
+        class_method = false
+        def_names = [def_node.to_a[0].to_s]
+        def_params = def_node.to_a[1].to_a
+        kind = :def
+      when :defs
+        parse_err 'targeted definitions on a non-self target are not supported', def_node \
+          unless def_node.to_a[0].type == :self
+        class_method = true
+        def_names = [def_node.to_a[1].to_s]
+        def_params = def_node.to_a[2].to_a
+        kind = :def
+      when :send
+        target, method_name, *parameters = *def_node
+
+        parse_err 'node after a sig must be a method definition', def_node \
+          unless [:attr_reader, :attr_writer, :attr_accessor].include?(method_name) \
+            || target != nil
+
+        parse_err 'typed attribute should have at least one name', def_node if parameters&.length == 0
+
+        kind = :attr
+        attr_direction = method_name.to_s.gsub('attr_', '').to_sym
+        def_names = T.must(parameters).map { |param| param.to_a[0].to_s }
+        class_method = false
+      else
+        parse_err 'node after a sig must be a method definition', def_node
+      end
+
+      if is_within_eigenclass
+        parse_err 'cannot represent multiple levels of eigenclassing', def_node if class_method
+        class_method = true
+      end
+
+      return_type = "T.untyped"
+
+      if kind == :def
+        parameters = def_params.map do |def_param|
+          arg_name = def_param.to_a[0]
+
+          # TODO: anonymous restarg
+          full_name = arg_name.to_s
+          full_name = "*#{arg_name}"  if def_param.type == :restarg
+          full_name = "**#{arg_name}" if def_param.type == :kwrestarg
+          full_name = "#{arg_name}:"  if def_param.type == :kwarg || def_param.type == :kwoptarg
+          full_name = "&#{arg_name}"  if def_param.type == :blockarg
+
+          default = def_param.to_a[1] ? node_to_s(def_param.to_a[1]) : nil
+          type = nil
+
+          RbiGenerator::Parameter.new(full_name, type: type, default: default)
+        end
+
+        # There should only be one ever here, but future-proofing anyway
+        def_names.map do |def_name|
+          RbiGenerator::Method.new(
+            DetachedRbiGenerator.new,
+            def_name,
+            parameters,
+            return_type,
+            class_method: class_method
+          )
+        end
+      elsif kind == :attr
+        case attr_direction
+        when :reader, :accessor, :writer
+          attr_type = return_type
+        else
+          raise "unknown attribute direction #{attr_direction}"
+        end
+
+        def_names.map do |def_name|
+          RbiGenerator::Attribute.new(
+            DetachedRbiGenerator.new,
+            def_name,
+            attr_direction,
+            attr_type,
+            class_attribute: class_method
+          )
+        end
+      else
+        raise "unknown definition kind #{kind}"
+      end
+    end
+
     protected
 
     sig { params(node: T.nilable(Parser::AST::Node)).returns(T::Array[Symbol]) }
@@ -518,6 +719,24 @@ module Parlour
         node.to_a[0].to_a[1] == :sig
     end
 
+    sig { params(path: NodePath).returns(T::Boolean) }
+    # Given a path, returns a boolean indicating whether the previous sibling
+    # represents a call to "sig" with a block.
+    #
+    # @param [NodePath] path The path to the namespace definition.
+    # @return [Boolean] True if that node represents a "sig" call, false
+    #   otherwise.
+    def previous_sibling_sig_node?(path)
+      previous_sibling = path.sibling(-1)
+      previous_node = previous_sibling.traverse(ast)
+      sig_node?(previous_node)
+    rescue IndexError, ArgumentError, TypeError
+      # `sibling` call could raise IndexError or ArgumentError if reaching into negative indices
+      # `traverse` call could raise TypeError if path doesn't return Parser::AST::Node
+
+      false
+    end
+
     sig { params(node: T.nilable(Parser::AST::Node)).returns(T.nilable(String)) }
     # Given an AST node, returns the source code from which it was constructed.
     # If the given AST node is nil, this returns nil.

data/lib/parlour/version.rb

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

data/parlour.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "parser"
 
   spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", ">= 12.3.3"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "sorbet"
   spec.add_development_dependency "simplecov"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parlour
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Aaron Christiansen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-22 00:00:00.000000000 Z
+date: 2020-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -84,16 +84,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -177,6 +177,8 @@ files:
 - lib/parlour/rbi_generator/options.rb
 - lib/parlour/rbi_generator/parameter.rb
 - lib/parlour/rbi_generator/rbi_object.rb
+- lib/parlour/rbi_generator/struct_class_namespace.rb
+- lib/parlour/rbi_generator/struct_prop.rb
 - lib/parlour/type_loader.rb
 - lib/parlour/type_parser.rb
 - lib/parlour/version.rb