cosmicgraph 0.49.0

data/lib/solargraph/parser/legacy/node_processors/args_node.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Legacy
+      module NodeProcessors
+        class ArgsNode < Parser::NodeProcessor::Base
+          def process
+            node.children.each do |u|
+              loc = get_node_location(u)
+              locals.push Solargraph::Pin::Parameter.new(
+                location: loc,
+                closure: region.closure,
+                comments: comments_for(node),
+                name: u.children[0].to_s,
+                assignment: u.children[1],
+                asgn_code: u.children[1] ? region.code_for(u.children[1]) : nil,
+                presence: region.closure.location.range,
+                decl: get_decl(u)
+              )
+              region.closure.parameters.push locals.last
+            end
+            process_children
+          end
+
+          private
+
+          def get_decl node
+            node.type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/legacy/node_processors/begin_node.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Legacy
+      module NodeProcessors
+        class BeginNode < Parser::NodeProcessor::Base
+          def process
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/legacy/node_processors/block_node.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Legacy
+      module NodeProcessors
+        class BlockNode < Parser::NodeProcessor::Base
+          include Legacy::NodeMethods
+
+          def process
+            location = get_node_location(node)
+            parent = if other_class_eval?
+              Solargraph::Pin::Namespace.new(
+                location: location,
+                type: :class,
+                name: unpack_name(node.children[0].children[0])
+              )
+            else
+              region.closure
+            end
+            pins.push Solargraph::Pin::Block.new(
+              location: location,
+              closure: parent,
+              receiver: node.children[0],
+              comments: comments_for(node),
+              scope: region.scope || region.closure.context.scope
+            )
+            process_children region.update(closure: pins.last)
+          end
+
+          private
+
+          def other_class_eval?
+            node.children[0].type == :send &&
+              node.children[0].children[1] == :class_eval &&
+              [:cbase, :const].include?(node.children[0].children[0]&.type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/legacy/node_processors/casgn_node.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Legacy
+      module NodeProcessors
+        class CasgnNode < Parser::NodeProcessor::Base
+          include Legacy::NodeMethods
+
+          def process
+            pins.push Solargraph::Pin::Constant.new(
+              location: get_node_location(node),
+              closure: region.closure,
+              name: const_name,
+              comments: comments_for(node),
+              assignment: node.children[2]
+            )
+            process_children
+          end
+
+          private
+
+          # @return [String]
+          def const_name
+            if node.children[0]
+              Parser::NodeMethods.unpack_name(node.children[0]) + "::#{node.children[1]}"
+            else
+              node.children[1].to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/legacy/node_processors/cvasgn_node.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Legacy
+      module NodeProcessors
+        class CvasgnNode < Parser::NodeProcessor::Base
+          def process
+            loc = get_node_location(node)
+            pins.push Solargraph::Pin::ClassVariable.new(
+              location: loc,
+              closure: region.closure,
+              name: node.children[0].to_s,
+              comments: comments_for(node),
+              assignment: node.children[1]
+            )
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/legacy/node_processors/def_node.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Legacy
+      module NodeProcessors
+        class DefNode < Parser::NodeProcessor::Base
+          def process
+            methpin = Solargraph::Pin::Method.new(
+              location: get_node_location(node),
+              closure: region.closure,
+              name: node.children[0].to_s,
+              comments: comments_for(node),
+              scope: region.scope || (region.closure.is_a?(Pin::Singleton) ? :class : :instance),
+              visibility: region.visibility,
+              node: node
+            )
+            if methpin.name == 'initialize' and methpin.scope == :instance
+              pins.push Solargraph::Pin::Method.new(
+                location: methpin.location,
+                closure: methpin.closure,
+                name: 'new',
+                comments: methpin.comments,
+                scope: :class,
+                parameters: methpin.parameters
+              )
+              # @todo Smelly instance variable access.
+              pins.last.instance_variable_set(:@return_type, ComplexType::SELF)
+              pins.push methpin
+              # @todo Smelly instance variable access.
+              methpin.instance_variable_set(:@visibility, :private)
+              methpin.instance_variable_set(:@return_type, ComplexType::VOID)
+            elsif region.visibility == :module_function
+              pins.push Solargraph::Pin::Method.new(
+                location: methpin.location,
+                closure: methpin.closure,
+                name: methpin.name,
+                comments: methpin.comments,
+                scope: :class,
+                visibility: :public,
+                parameters: methpin.parameters,
+                node: methpin.node
+              )
+              pins.push Solargraph::Pin::Method.new(
+                location: methpin.location,
+                closure: methpin.closure,
+                name: methpin.name,
+                comments: methpin.comments,
+                scope: :instance,
+                visibility: :private,
+                parameters: methpin.parameters,
+                node: methpin.node
+              )
+            else
+              pins.push methpin
+            end
+            process_children region.update(closure: methpin, scope: methpin.scope)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/legacy/node_processors/defs_node.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Legacy
+      module NodeProcessors
+        class DefsNode < DefNode
+          include Legacy::NodeMethods
+
+          def process
+            s_visi = region.visibility
+            s_visi = :public if s_visi == :module_function || region.scope != :class
+            loc = get_node_location(node)
+            if node.children[0].is_a?(AST::Node) && node.children[0].type == :self
+              closure = region.closure
+            else
+              closure = Solargraph::Pin::Namespace.new(
+                name: unpack_name(node.children[0])
+              )
+            end
+            pins.push Solargraph::Pin::Method.new(
+              location: loc,
+              closure: closure,
+              name: node.children[1].to_s,
+              comments: comments_for(node),
+              scope: :class,
+              visibility: s_visi,
+              node: node
+            )
+            process_children region.update(closure: pins.last, scope: :class)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/legacy/node_processors/gvasgn_node.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Legacy
+      module NodeProcessors
+        class GvasgnNode < Parser::NodeProcessor::Base
+          def process
+            loc = get_node_location(node)
+            pins.push Solargraph::Pin::GlobalVariable.new(
+              location: loc,
+              closure: region.closure,
+              name: node.children[0].to_s,
+              comments: comments_for(node),
+              assignment: node.children[1]
+            )
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/legacy/node_processors/ivasgn_node.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Legacy
+      module NodeProcessors
+        class IvasgnNode < Parser::NodeProcessor::Base
+          include Legacy::NodeMethods
+
+          def process
+            loc = get_node_location(node)
+            pins.push Solargraph::Pin::InstanceVariable.new(
+              location: loc,
+              closure: region.closure,
+              name: node.children[0].to_s,
+              comments: comments_for(node),
+              assignment: node.children[1]
+            )
+            if region.visibility == :module_function
+              here = get_node_start_position(node)
+              named_path = named_path_pin(here)
+              if named_path.is_a?(Pin::Method)
+                pins.push Solargraph::Pin::InstanceVariable.new(
+                  location: loc,
+                  closure: Pin::Namespace.new(type: :module, closure: region.closure.closure, name: region.closure.name),
+                  name: node.children[0].to_s,
+                  comments: comments_for(node),
+                  assignment: node.children[1]
+                )
+              end
+            end
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/legacy/node_processors/lvasgn_node.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Legacy
+      module NodeProcessors
+        class LvasgnNode < Parser::NodeProcessor::Base
+          include Legacy::NodeMethods
+
+          def process
+            here = get_node_start_position(node)
+            presence = Range.new(here, region.closure.location.range.ending)
+            loc = get_node_location(node)
+            locals.push Solargraph::Pin::LocalVariable.new(
+              location: loc,
+              closure: region.closure,
+              name: node.children[0].to_s,
+              assignment: node.children[1],
+              comments: comments_for(node),
+              presence: presence
+            )
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/legacy/node_processors/namespace_node.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Legacy
+      module NodeProcessors
+        class NamespaceNode < Parser::NodeProcessor::Base
+          include Legacy::NodeMethods
+
+          def process
+            sc = nil
+            if node.type == :class and !node.children[1].nil?
+              sc = unpack_name(node.children[1])
+            end
+            loc = get_node_location(node)
+            nspin = Solargraph::Pin::Namespace.new(
+              type: node.type,
+              location: loc,
+              closure: region.closure,
+              name: unpack_name(node.children[0]),
+              comments: comments_for(node),
+              visibility: :public,
+              gates: region.closure.gates.freeze
+            )
+            pins.push nspin
+            unless sc.nil?
+              pins.push Pin::Reference::Superclass.new(
+                location: loc,
+                closure: pins.last,
+                name: sc
+              )
+            end
+            process_children region.update(closure: nspin, visibility: :public)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/legacy/node_processors/orasgn_node.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Legacy
+      module NodeProcessors
+        class OrasgnNode < Parser::NodeProcessor::Base
+          def process
+            new_node = node.updated(node.children[0].type, node.children[0].children + [node.children[1]])
+            NodeProcessor.process(new_node, region, pins, locals)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/legacy/node_processors/resbody_node.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Legacy
+      module NodeProcessors
+        class ResbodyNode < Parser::NodeProcessor::Base
+          include Legacy::NodeMethods
+
+          def process
+            if node.children[1]
+              here = get_node_start_position(node.children[1])
+              presence = Range.new(here, region.closure.location.range.ending)
+              loc = get_node_location(node.children[1])
+              types = if node.children[0].nil?
+                        ['Exception']
+                      else
+                        node.children[0].children.map do |child|
+                          unpack_name(child)
+                        end
+                      end
+              locals.push Solargraph::Pin::LocalVariable.new(
+                location: loc,
+                closure: region.closure,
+                name: node.children[1].children[0].to_s,
+                comments: "@type [#{types.join(',')}]",
+                presence: presence
+              )
+            end
+            NodeProcessor.process(node.children[2], region, pins, locals)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/legacy/node_processors/sclass_node.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module Legacy
+      module NodeProcessors
+        class SclassNode < Parser::NodeProcessor::Base
+          def process
+            sclass = node.children[0]
+            if sclass.is_a?(AST::Node) && sclass.type == :self
+              closure = region.closure
+            elsif sclass.is_a?(AST::Node) && sclass.type == :casgn
+              names = [region.closure.namespace, region.closure.name]
+              if sclass.children[0].nil? && names.last != sclass.children[1].to_s
+                names << sclass.children[1].to_s
+              else
+                names.concat [NodeMethods.unpack_name(sclass.children[0]), sclass.children[1].to_s]
+              end
+              name = names.reject(&:empty?).join('::')
+              closure = Solargraph::Pin::Namespace.new(name: name, location: region.closure.location)
+            elsif sclass.is_a?(AST::Node) && sclass.type == :const
+              names = [region.closure.namespace, region.closure.name]
+              also = NodeMethods.unpack_name(sclass)
+              if also != region.closure.name
+                names << also
+              end
+              name = names.reject(&:empty?).join('::')
+              closure = Solargraph::Pin::Namespace.new(name: name, location: region.closure.location)
+            else
+              return
+            end
+            pins.push Solargraph::Pin::Singleton.new(
+              location: get_node_location(node),
+              closure: closure
+            )
+            process_children region.update(visibility: :public, scope: :class, closure: pins.last)
+          end
+        end
+      end
+    end
+  end
+end