solargraph 0.61.0 → 0.62.0

data/lib/solargraph/convention/struct_definition/struct_definition_node.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Convention
-    module StructDefinition
-      # A node wrapper for a Struct definition via inheritance.
-      # @example
-      #   class MyStruct < Struct.new(:bar, :baz)
-      #     def foo
-      #     end
-      #   end
-      class StructDefintionNode
-        class << self
-          # @example
-          #   s(:class,
-          #     s(:const, nil, :Foo),
-          #     s(:send,
-          #       s(:const, nil, :Struct), :new,
-          #       s(:sym, :bar),
-          #       s(:sym, :baz)),
-          #       s(:hash,
-          #         s(:pair,
-          #           s(:sym, :keyword_init),
-          #           s(:true)))),
-          #     s(:def, :foo,
-          #       s(:args),
-          #       s(:send, nil, :bar)))
-          #
-          # @param node [Parser::AST::Node]
-          def match? node
-            return false unless node&.type == :class
-
-            struct_definition_node?(node.children[1])
-          end
-
-          private
-
-          # @param struct_node [Parser::AST::Node]
-          # @return [Boolean]
-          def struct_definition_node? struct_node
-            return false unless struct_node.is_a?(::Parser::AST::Node)
-            return false unless struct_node&.type == :send
-            return false unless struct_node.children[0]&.type == :const
-            return false unless struct_node.children[0].children[1] == :Struct
-            return false unless struct_node.children[1] == :new
-
-            true
-          end
-        end
-
-        # @param node [Parser::AST::Node]
-        def initialize node
-          @node = node
-        end
-
-        # @return [String]
-        def class_name
-          Parser::NodeMethods.unpack_name(node)
-        end
-
-        # @return [Array<Array(Parser::AST::Node, String)>]
-        def attributes
-          struct_attribute_nodes.map do |struct_def_param|
-            next unless struct_def_param.type == :sym
-            [struct_def_param, struct_def_param.children[0].to_s]
-          end.compact
-        end
-
-        def keyword_init?
-          keyword_init_param = struct_attribute_nodes.find do |struct_def_param|
-            struct_def_param.type == :hash && struct_def_param.children[0].type == :pair &&
-              struct_def_param.children[0].children[0].children[0] == :keyword_init
-          end
-
-          return false if keyword_init_param.nil?
-
-          keyword_init_param.children[0].children[1].type == :true
-        end
-
-        # @return [Parser::AST::Node]
-        def body_node
-          node.children[2]
-        end
-
-        private
-
-        # @return [Parser::AST::Node]
-        attr_reader :node
-
-        # @return [Parser::AST::Node]
-        def struct_node
-          node.children[1]
-        end
-
-        # @sg-ignore Need to add nil check here
-        # @return [Array<Parser::AST::Node>]
-        def struct_attribute_nodes
-          struct_node.children[2..-1]
-        end
-      end
-    end
-  end
-end

data/lib/solargraph/convention/struct_definition.rb

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Convention
-    module StructDefinition
-      autoload :StructDefintionNode, 'solargraph/convention/struct_definition/struct_definition_node'
-      autoload :StructAssignmentNode, 'solargraph/convention/struct_definition/struct_assignment_node'
-
-      module NodeProcessors
-        class StructNode < Parser::NodeProcessor::Base
-          # @return [Boolean] continue processing the next processor of the same node.
-          def process
-            return true if struct_definition_node.nil?
-
-            loc = get_node_location(node)
-            nspin = Solargraph::Pin::Namespace.new(
-              type: :class,
-              location: loc,
-              closure: region.closure,
-              # @sg-ignore flow sensitive typing needs to handle attrs
-              name: struct_definition_node.class_name,
-              docstring: docstring,
-              visibility: :public,
-              gates: region.closure.gates.freeze,
-              source: :struct_definition
-            )
-            pins.push nspin
-
-            # define initialize method
-            initialize_method_pin = Pin::Method.new(
-              name: 'initialize',
-              parameters: [],
-              scope: :instance,
-              location: get_node_location(node),
-              closure: nspin,
-              visibility: :private,
-              docstring: docstring,
-              source: :struct_definition
-            )
-
-            pins.push initialize_method_pin
-
-            # @sg-ignore flow sensitive typing needs to handle attrs
-            struct_definition_node.attributes.map do |attribute_node, attribute_name|
-              initialize_method_pin.parameters.push(
-                Pin::Parameter.new(
-                  name: attribute_name,
-                  decl: struct_definition_node.keyword_init? ? :kwarg : :arg,
-                  location: get_node_location(attribute_node),
-                  closure: initialize_method_pin,
-                  source: :struct_definition
-                )
-              )
-            end
-
-            # define attribute accessors and instance variables
-            # @sg-ignore flow sensitive typing needs to handle attrs
-            struct_definition_node.attributes.each do |attribute_node, attribute_name|
-              [attribute_name, "#{attribute_name}="].each do |name|
-                docs = docstring.tags.find { |t| t.tag_name == 'param' && t.name == attribute_name }
-
-                attribute_type = ComplexType.parse(tag_string(docs))
-                return_type_comment = attribute_comment(docs, false)
-                param_comment = attribute_comment(docs, true)
-
-                method_pin = Pin::Method.new(
-                  name: name,
-                  parameters: [],
-                  scope: :instance,
-                  location: get_node_location(attribute_node),
-                  closure: nspin,
-                  docstring: YARD::Docstring.new(return_type_comment),
-                  # even assignments return the value
-                  comments: return_type_comment,
-                  return_type: attribute_type,
-                  visibility: :public,
-                  source: :struct_definition
-                )
-
-                if name.end_with?('=')
-                  method_pin.parameters << Pin::Parameter.new(
-                    name: attribute_name,
-                    location: get_node_location(attribute_node),
-                    closure: method_pin,
-                    return_type: attribute_type,
-                    comments: param_comment,
-                    source: :struct_definition
-                  )
-
-                  pins.push Pin::InstanceVariable.new(name: "@#{attribute_name}",
-                                                      closure: method_pin,
-                                                      location: get_node_location(attribute_node),
-                                                      return_type: attribute_type,
-                                                      comments: "@type [#{attribute_type.rooted_tags}]",
-                                                      source: :struct_definition)
-                end
-
-                pins.push method_pin
-              end
-            end
-
-            process_children region.update(closure: nspin, visibility: :public)
-            false
-          end
-
-          private
-
-          # @return [StructDefinition::StructDefintionNode, StructDefinition::StructAssignmentNode, nil]
-          def struct_definition_node
-            @struct_definition_node ||= if StructDefintionNode.match?(node)
-                                          StructDefintionNode.new(node)
-                                        elsif StructAssignmentNode.match?(node)
-                                          StructAssignmentNode.new(node)
-                                        end
-          end
-
-          # Gets/generates the relevant docstring for this struct & it's attributes
-          # @return [YARD::Docstring]
-          def docstring
-            @docstring ||= parse_comments
-          end
-
-          # Parses any relevant comments for a struct int a yard docstring
-          # @return [YARD::Docstring]
-          def parse_comments
-            struct_comments = comments_for(node) || ''
-            # @sg-ignore Need to add nil check here
-            struct_definition_node.attributes.each do |attr_node, attr_name|
-              comment = comments_for(attr_node)
-              next if comment.nil?
-
-              # We should support specific comments for an attribute, and that can be either a @return on an @param
-              # But since we merge into the struct_comments, then we should interpret either as a param
-              comment = "@param #{attr_name}#{comment[7..]}" if comment.start_with?('@return')
-
-              struct_comments += "\n#{comment}"
-            end
-
-            Solargraph::Source.parse_docstring(struct_comments).to_docstring
-          end
-
-          # @param tag [YARD::Tags::Tag, nil] The param tag for this attribute.xtract_
-          #
-          # @return [String]
-          def tag_string tag
-            tag&.types&.join(',') || 'undefined'
-          end
-
-          # @param tag [YARD::Tags::Tag, nil] The param tag for this attribute. If nil, this method is a no-op
-          # @param for_setter [Boolean] If true, will return a @param tag instead of a @return tag
-          #
-          # @return [String] The formatted comment for the attribute
-          def attribute_comment tag, for_setter
-            return '' if tag.nil?
-
-            suffix = "[#{tag_string(tag)}] #{tag.text}"
-
-            if for_setter
-              "@param #{tag.name} #{suffix}"
-            else
-              "@return #{suffix}"
-            end
-          end
-        end
-      end
-    end
-  end
-end