solargraph 0.58.0 → 0.59.0.dev.1

data/lib/solargraph/convention/data_definition/data_definition_node.rb

@@ -1,91 +1,93 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Convention
-    module DataDefinition
-      # A node wrapper for a Data definition via inheritance.
-      # @example
-      #   class MyData < Data.new(:bar, :baz)
-      #     def foo
-      #     end
-      #   end
-      class DataDefintionNode
-        class << self
-          # @example
-          #   s(:class,
-          #     s(:const, nil, :Foo),
-          #     s(:send,
-          #       s(:const, nil, :Data), :define,
-          #       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
-
-            data_definition_node?(node.children[1])
-          end
-
-          private
-
-          # @param data_node [Parser::AST::Node]
-          # @return [Boolean]
-          def data_definition_node?(data_node)
-            return false unless data_node.is_a?(::Parser::AST::Node)
-            return false unless data_node&.type == :send
-            return false unless data_node.children[0]&.type == :const
-            return false unless data_node.children[0].children[1] == :Data
-            return false unless data_node.children[1] == :define
-
-            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
-          data_attribute_nodes.map do |data_def_param|
-            next unless data_def_param.type == :sym
-            [data_def_param, data_def_param.children[0].to_s]
-          end.compact
-        end
-
-        # @return [Parser::AST::Node]
-        def body_node
-          node.children[2]
-        end
-
-        private
-
-        # @return [Parser::AST::Node]
-        attr_reader :node
-
-        # @return [Parser::AST::Node, nil]
-        def data_node
-          node.children[1]
-        end
-
-        # @return [Array<Parser::AST::Node>]
-        def data_attribute_nodes
-          data_node.children[2..-1]
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    module DataDefinition
+      # A node wrapper for a Data definition via inheritance.
+      # @example
+      #   class MyData < Data.new(:bar, :baz)
+      #     def foo
+      #     end
+      #   end
+      class DataDefintionNode
+        class << self
+          # @example
+          #   s(:class,
+          #     s(:const, nil, :Foo),
+          #     s(:send,
+          #       s(:const, nil, :Data), :define,
+          #       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
+
+            data_definition_node?(node.children[1])
+          end
+
+          private
+
+          # @param data_node [Parser::AST::Node]
+          # @return [Boolean]
+          def data_definition_node?(data_node)
+            return false unless data_node.is_a?(::Parser::AST::Node)
+            return false unless data_node&.type == :send
+            return false unless data_node.children[0]&.type == :const
+            return false unless data_node.children[0].children[1] == :Data
+            return false unless data_node.children[1] == :define
+
+            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
+          data_attribute_nodes.map do |data_def_param|
+            next unless data_def_param.type == :sym
+            [data_def_param, data_def_param.children[0].to_s]
+          end.compact
+        end
+
+        # @return [Parser::AST::Node, nil]
+        def body_node
+          node.children[2]
+        end
+
+        private
+
+        # @return [Parser::AST::Node]
+        attr_reader :node
+
+        # @return [Parser::AST::Node, nil]
+        def data_node
+          node.children[1]
+        end
+
+        # @sg-ignore Need to add nil check here
+        # @return [Array<Parser::AST::Node>]
+        def data_attribute_nodes
+          # @sg-ignore Need to add nil check here
+          data_node.children[2..-1]
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/convention/data_definition.rb

@@ -1,105 +1,108 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Convention
-    module DataDefinition
-      autoload :DataDefintionNode, 'solargraph/convention/data_definition/data_definition_node'
-      autoload :DataAssignmentNode, 'solargraph/convention/data_definition/data_assignment_node'
-
-      module NodeProcessors
-        class DataNode < Parser::NodeProcessor::Base
-          # @return [Boolean] continue processing the next processor of the same node.
-          def process
-            return true if data_definition_node.nil?
-
-            loc = get_node_location(node)
-            nspin = Solargraph::Pin::Namespace.new(
-              type: :class,
-              location: loc,
-              closure: region.closure,
-              name: data_definition_node.class_name,
-              comments: comments_for(node),
-              visibility: :public,
-              gates: region.closure.gates.freeze
-            )
-            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,
-              comments: comments_for(node)
-            )
-
-            # @todo Support both arg and kwarg initializers for Data.define
-            # Solargraph::SourceMap::Clip#complete_keyword_parameters does not seem to currently take into account [Pin::Method#signatures] hence we only one for :kwarg
-            pins.push initialize_method_pin
-
-            data_definition_node.attributes.map do |attribute_node, attribute_name|
-              initialize_method_pin.parameters.push(
-                Pin::Parameter.new(
-                  name: attribute_name,
-                  decl: :kwarg,
-                  location: get_node_location(attribute_node),
-                  closure: initialize_method_pin
-                )
-              )
-            end
-
-            # define attribute readers and instance variables
-            data_definition_node.attributes.each do |attribute_node, attribute_name|
-              name = attribute_name.to_s
-              method_pin = Pin::Method.new(
-                name: name,
-                parameters: [],
-                scope: :instance,
-                location: get_node_location(attribute_node),
-                closure: nspin,
-                comments: attribute_comments(attribute_node, attribute_name),
-                visibility: :public
-              )
-
-              pins.push method_pin
-
-              pins.push Pin::InstanceVariable.new(name: "@#{attribute_name}",
-                                                  closure: method_pin,
-                                                  location: get_node_location(attribute_node),
-                                                  comments: attribute_comments(attribute_node, attribute_name))
-            end
-
-            process_children region.update(closure: nspin, visibility: :public)
-
-            false
-          end
-
-          private
-
-          # @return [DataDefintionNode, nil]
-          def data_definition_node
-            @data_definition_node ||= if DataDefintionNode.match?(node)
-                                        DataDefintionNode.new(node)
-                                      elsif DataAssignmentNode.match?(node)
-                                        DataAssignmentNode.new(node)
-                                      end
-          end
-
-          # @param attribute_node [Parser::AST::Node]
-          # @param attribute_name [String]
-          # @return [String, nil]
-          def attribute_comments(attribute_node, attribute_name)
-            data_comments = comments_for(attribute_node)
-            return if data_comments.nil? || data_comments.empty?
-
-            data_comments.split("\n").find do |row|
-              row.include?(attribute_name)
-            end&.gsub('@param', '@return')&.gsub(attribute_name, '')
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    module DataDefinition
+      autoload :DataDefintionNode, 'solargraph/convention/data_definition/data_definition_node'
+      autoload :DataAssignmentNode, 'solargraph/convention/data_definition/data_assignment_node'
+
+      module NodeProcessors
+        class DataNode < Parser::NodeProcessor::Base
+          # @return [Boolean] continue processing the next processor of the same node.
+          def process
+            return true if data_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: data_definition_node.class_name,
+              comments: comments_for(node),
+              visibility: :public,
+              gates: region.closure.gates.freeze
+            )
+            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,
+              comments: comments_for(node)
+            )
+
+            # @todo Support both arg and kwarg initializers for Data.define
+            # Solargraph::SourceMap::Clip#complete_keyword_parameters does not seem to currently take into account [Pin::Method#signatures] hence we only one for :kwarg
+            pins.push initialize_method_pin
+
+            # @sg-ignore flow sensitive typing needs to handle attrs
+            data_definition_node.attributes.map do |attribute_node, attribute_name|
+              initialize_method_pin.parameters.push(
+                Pin::Parameter.new(
+                  name: attribute_name,
+                  decl: :kwarg,
+                  location: get_node_location(attribute_node),
+                  closure: initialize_method_pin
+                )
+              )
+            end
+
+            # define attribute readers and instance variables
+            # @sg-ignore flow sensitive typing needs to handle attrs
+            data_definition_node.attributes.each do |attribute_node, attribute_name|
+              name = attribute_name.to_s
+              method_pin = Pin::Method.new(
+                name: name,
+                parameters: [],
+                scope: :instance,
+                location: get_node_location(attribute_node),
+                closure: nspin,
+                comments: attribute_comments(attribute_node, attribute_name),
+                visibility: :public
+              )
+
+              pins.push method_pin
+
+              pins.push Pin::InstanceVariable.new(name: "@#{attribute_name}",
+                                                  closure: method_pin,
+                                                  location: get_node_location(attribute_node),
+                                                  comments: attribute_comments(attribute_node, attribute_name))
+            end
+
+            process_children region.update(closure: nspin, visibility: :public)
+
+            false
+          end
+
+          private
+
+          # @return [DataDefinition::DataDefintionNode, DataDefinition::DataAssignmentNode, nil]
+          def data_definition_node
+            @data_definition_node ||= if DataDefintionNode.match?(node)
+                                        DataDefintionNode.new(node)
+                                      elsif DataAssignmentNode.match?(node)
+                                        DataAssignmentNode.new(node)
+                                      end
+          end
+
+          # @param attribute_node [Parser::AST::Node]
+          # @param attribute_name [String]
+          # @return [String, nil]
+          def attribute_comments(attribute_node, attribute_name)
+            data_comments = comments_for(attribute_node)
+            return if data_comments.nil? || data_comments.empty?
+
+            data_comments.split("\n").find do |row|
+              row.include?(attribute_name)
+            end&.gsub('@param', '@return')&.gsub(attribute_name, '')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,61 +1,62 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Convention
-    module StructDefinition
-      # A node wrapper for a Struct definition via const assignment.
-      # @example
-      #   MyStruct = Struct.new(:bar, :baz) do
-      #     def foo
-      #     end
-      #   end
-      class StructAssignmentNode < StructDefintionNode
-        class << self
-          # @example
-          # s(:casgn, nil, :Foo,
-          #   s(:block,
-          #     s(:send,
-          #       s(:const, nil, :Struct), :new,
-          #       s(:sym, :bar),
-          #       s(:sym, :baz)),
-          #     s(:args),
-          #     s(:def, :foo,
-          #       s(:args),
-          #       s(:send, nil, :bar))))
-          # @param node [Parser::AST::Node]
-          def match?(node)
-            return false unless node&.type == :casgn
-            return false if node.children[2].nil?
-
-            struct_node = if node.children[2].type == :block
-                            node.children[2].children[0]
-                          else
-                            node.children[2]
-                          end
-
-            struct_definition_node?(struct_node)
-          end
-        end
-
-        def class_name
-          if node.children[0]
-            Parser::NodeMethods.unpack_name(node.children[0]) + "::#{node.children[1]}"
-          else
-            node.children[1].to_s
-          end
-        end
-
-        private
-
-        # @return [Parser::AST::Node]
-        def struct_node
-          if node.children[2].type == :block
-            node.children[2].children[0]
-          else
-            node.children[2]
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    module StructDefinition
+      # A node wrapper for a Struct definition via const assignment.
+      # @example
+      #   MyStruct = Struct.new(:bar, :baz) do
+      #     def foo
+      #     end
+      #   end
+      class StructAssignmentNode < StructDefintionNode
+        class << self
+          # @example
+          # s(:casgn, nil, :Foo,
+          #   s(:block,
+          #     s(:send,
+          #       s(:const, nil, :Struct), :new,
+          #       s(:sym, :bar),
+          #       s(:sym, :baz)),
+          #     s(:args),
+          #     s(:def, :foo,
+          #       s(:args),
+          #       s(:send, nil, :bar))))
+          #
+          # @param node [Parser::AST::Node]
+          def match?(node)
+            return false unless node&.type == :casgn
+            return false if node.children[2].nil?
+
+            struct_node = if node.children[2].type == :block
+                            node.children[2].children[0]
+                          else
+                            node.children[2]
+                          end
+
+            struct_definition_node?(struct_node)
+          end
+        end
+
+        def class_name
+          if node.children[0]
+            Parser::NodeMethods.unpack_name(node.children[0]) + "::#{node.children[1]}"
+          else
+            node.children[1].to_s
+          end
+        end
+
+        private
+
+        # @return [Parser::AST::Node]
+        def struct_node
+          if node.children[2].type == :block
+            node.children[2].children[0]
+          else
+            node.children[2]
+          end
+        end
+      end
+    end
+  end
+end