solargraph 0.54.4 → 0.58.3

data/lib/solargraph/convention/struct_definition.rb

@@ -0,0 +1,164 @@
+# 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,
+              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
+
+            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
+            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 [StructDefintionNode, 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) || ''
+            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

data/lib/solargraph/convention.rb

@@ -1,47 +1,78 @@
-# frozen_string_literal: true
-
-
-module Solargraph
-  # Conventions provide a way to modify an ApiMap based on expectations about
-  # one of its sources.
-  #
-  module Convention
-    autoload :Base,    'solargraph/convention/base'
-    autoload :Gemfile, 'solargraph/convention/gemfile'
-    autoload :Gemspec, 'solargraph/convention/gemspec'
-    autoload :Rakefile, 'solargraph/convention/rakefile'
-
-    # @type [Set<Convention::Base>]
-    @@conventions = Set.new
-
-    # @param convention [Class<Convention::Base>]
-    # @return [void]
-    def self.register convention
-      @@conventions.add convention.new
-    end
-
-    # @param source_map [SourceMap]
-    # @return [Environ]
-    def self.for_local(source_map)
-      result = Environ.new
-      @@conventions.each do |conv|
-        result.merge conv.local(source_map)
-      end
-      result
-    end
-
-    # @param yard_map [YardMap]
-    # @return [Environ]
-    def self.for_global(yard_map)
-      result = Environ.new
-      @@conventions.each do |conv|
-        result.merge conv.global(yard_map)
-      end
-      result
-    end
-
-    register Gemfile
-    register Gemspec
-    register Rakefile
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  # Conventions provide a way to modify an ApiMap based on expectations about
+  # one of its sources.
+  #
+  module Convention
+    autoload :Base,    'solargraph/convention/base'
+    autoload :Gemfile, 'solargraph/convention/gemfile'
+    autoload :Gemspec, 'solargraph/convention/gemspec'
+    autoload :Rakefile, 'solargraph/convention/rakefile'
+    autoload :StructDefinition, 'solargraph/convention/struct_definition'
+    autoload :DataDefinition,   'solargraph/convention/data_definition'
+    autoload :ActiveSupportConcern, 'solargraph/convention/active_support_concern'
+
+    # @type [Set<Convention::Base>]
+    @@conventions = Set.new
+
+    # @param convention [Class<Convention::Base>]
+    # @return [void]
+    def self.register convention
+      @@conventions.add convention.new
+    end
+
+    # @param convention [Class<Convention::Base>]
+    # @return [void]
+    def self.unregister convention
+      @@conventions.delete_if { |c| c.is_a?(convention) }
+    end
+
+    # @param source_map [SourceMap]
+    # @return [Environ]
+    def self.for_local(source_map)
+      result = Environ.new
+      @@conventions.each do |conv|
+        result.merge conv.local(source_map)
+      end
+      result
+    end
+
+    # @param doc_map [DocMap]
+    # @return [Environ]
+    def self.for_global(doc_map)
+      result = Environ.new
+      @@conventions.each do |conv|
+        result.merge conv.global(doc_map)
+      end
+      result
+    end
+
+    # Provides any additional method pins based on the described object.
+    #
+    # @param api_map [ApiMap]
+    # @param rooted_tag [String] A fully qualified namespace, with
+    #   generic parameter values if applicable
+    # @param scope [Symbol] :class or :instance
+    # @param visibility [Array<Symbol>] :public, :protected, and/or :private
+    # @param deep [Boolean]
+    # @param skip [Set<String>]
+    # @param no_core [Boolean] Skip core classes if true
+    #
+    # @return [Environ]
+    def self.for_object api_map, rooted_tag, scope, visibility,
+                        deep, skip, no_core
+      result = Environ.new
+      @@conventions.each do |conv|
+        result.merge conv.object(api_map, rooted_tag, scope, visibility,
+                                 deep, skip, no_core)
+      end
+      result
+    end
+
+    register Gemfile
+    register Gemspec
+    register Rakefile
+    register ActiveSupportConcern
+  end
+end

data/lib/solargraph/converters/dd.rb

@@ -1,17 +1,17 @@
-require 'nokogiri'
-
-module ReverseMarkdown
-  module Converters
-    class Dd < Base
-      # @return [String]
-      # @param node [Nokogiri::XML::Element]
-      # @param state [Hash]
-      def convert node, state = {}
-        content = treat_children(node, state)
-        ": #{content.strip}\n"
-      end
-    end
-  end
-end
-
-ReverseMarkdown::Converters.register :dd, ReverseMarkdown::Converters::Dd.new
+require 'nokogiri'
+
+module ReverseMarkdown
+  module Converters
+    class Dd < Base
+      # @return [String]
+      # @param node [Nokogiri::XML::Element]
+      # @param state [Hash]
+      def convert node, state = {}
+        content = treat_children(node, state)
+        ": #{content.strip}\n"
+      end
+    end
+  end
+end
+
+ReverseMarkdown::Converters.register :dd, ReverseMarkdown::Converters::Dd.new

data/lib/solargraph/converters/dl.rb

@@ -1,15 +1,15 @@
-module ReverseMarkdown
-  module Converters
-    class Dl < Base
-      # @return [String]
-      # @param node [Nokogiri::XML::Element]
-      # @param state [Hash]
-      def convert node, state = {}
-        content = treat_children(node, state).strip
-        "\n\n#{content}\n"
-      end
-    end
-  end
-end
-
-ReverseMarkdown::Converters.register :dl, ReverseMarkdown::Converters::Dl.new
+module ReverseMarkdown
+  module Converters
+    class Dl < Base
+      # @return [String]
+      # @param node [Nokogiri::XML::Element]
+      # @param state [Hash]
+      def convert node, state = {}
+        content = treat_children(node, state).strip
+        "\n\n#{content}\n"
+      end
+    end
+  end
+end
+
+ReverseMarkdown::Converters.register :dl, ReverseMarkdown::Converters::Dl.new

data/lib/solargraph/converters/dt.rb

@@ -1,15 +1,15 @@
-module ReverseMarkdown
-  module Converters
-    class Dt < Base
-      # @return [String]
-      # @param node [Nokogiri::XML::Element]
-      # @param state [Hash]
-      def convert node, state = {}
-        content = treat_children(node, state)
-        "\n#{content.strip}\n"
-      end
-    end
-  end
-end
-
-ReverseMarkdown::Converters.register :dt, ReverseMarkdown::Converters::Dt.new
+module ReverseMarkdown
+  module Converters
+    class Dt < Base
+      # @return [String]
+      # @param node [Nokogiri::XML::Element]
+      # @param state [Hash]
+      def convert node, state = {}
+        content = treat_children(node, state)
+        "\n#{content.strip}\n"
+      end
+    end
+  end
+end
+
+ReverseMarkdown::Converters.register :dt, ReverseMarkdown::Converters::Dt.new

data/lib/solargraph/converters/misc.rb

@@ -1 +1 @@
-ReverseMarkdown::Converters.register :tt, ReverseMarkdown::Converters::Code.new
+ReverseMarkdown::Converters.register :tt, ReverseMarkdown::Converters::Code.new

data/lib/solargraph/diagnostics/require_not_found.rb

@@ -1,53 +1,53 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Diagnostics
-    # RequireNotFound reports required paths that could not be resolved to
-    # either a file in the workspace or a gem.
-    #
-    class RequireNotFound < Base
-      def diagnose source, api_map
-        return [] unless source.parsed? && source.synchronized?
-        result = []
-        refs = {}
-        map = api_map.source_map(source.filename)
-        map.requires.each { |ref| refs[ref.name] = ref }
-        api_map.missing_docs.each do |r|
-          next unless refs.key?(r)
-          result.push docs_error(r, refs[r].location)
-        end
-        api_map.unresolved_requires.each do |r|
-          next unless refs.key?(r)
-          result.push require_error(r, refs[r].location)
-        end
-        result
-      end
-
-      private
-
-      # @param path [String]
-      # @param location [Location]
-      # @return [Hash]
-      def docs_error path, location
-        {
-          range: location.range.to_hash,
-          severity: Diagnostics::Severities::WARNING,
-          source: 'RequireNotFound',
-          message: "YARD docs not found for #{path}"
-        }
-      end
-
-      # @param path [String]
-      # @param location [Location]
-      # @return [Hash]
-      def require_error path, location
-        {
-          range: location.range.to_hash,
-          severity: Diagnostics::Severities::WARNING,
-          source: 'RequireNotFound',
-          message: "Required path #{path} could not be resolved."
-        }
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Diagnostics
+    # RequireNotFound reports required paths that could not be resolved to
+    # either a file in the workspace or a gem.
+    #
+    class RequireNotFound < Base
+      def diagnose source, api_map
+        return [] unless source.parsed? && source.synchronized?
+        result = []
+        refs = {}
+        map = api_map.source_map(source.filename)
+        map.requires.each { |ref| refs[ref.name] = ref }
+        api_map.missing_docs.each do |r|
+          next unless refs.key?(r)
+          result.push docs_error(r, refs[r].location)
+        end
+        api_map.unresolved_requires.each do |r|
+          next unless refs.key?(r)
+          result.push require_error(r, refs[r].location)
+        end
+        result
+      end
+
+      private
+
+      # @param path [String]
+      # @param location [Location]
+      # @return [Hash]
+      def docs_error path, location
+        {
+          range: location.range.to_hash,
+          severity: Diagnostics::Severities::WARNING,
+          source: 'RequireNotFound',
+          message: "YARD docs not found for #{path}"
+        }
+      end
+
+      # @param path [String]
+      # @param location [Location]
+      # @return [Hash]
+      def require_error path, location
+        {
+          range: location.range.to_hash,
+          severity: Diagnostics::Severities::WARNING,
+          source: 'RequireNotFound',
+          message: "Required path #{path} could not be resolved."
+        }
+      end
+    end
+  end
+end