yoda-language-server 0.4.0

data/lib/yoda/model/values/module_value.rb

@@ -0,0 +1,72 @@
+module Yoda
+  module Model
+    module Values
+      class ModuleValue < Base
+        attr_reader :registry, :namespace_object
+
+        # @param registry [Registry]
+        # @param namespace_object [::YARD::CodeObjects::NamespaceObject, ::YARD::CodeObjects::Proxy]
+        def initialize(registry, namespace_object)
+          fail ArgumentError, registry unless registry.is_a?(Registry)
+          fail ArgumentError, namespace_object unless namespace_object.is_a?(::YARD::CodeObjects::NamespaceObject) || namespace_object.is_a?(::YARD::CodeObjects::Proxy)
+          @registry = registry
+          @namespace_object = namespace_object
+        end
+
+        # @return [Array<Functions::Base>]
+        def methods(visibility: nil)
+          return [] if namespace_object.type == :proxy
+          @methods ||= begin
+            opts = { scope: :class, visibility: visibility }.compact
+            class_methods = namespace_object.meths(opts).map { |meth| Functions::Method.new(meth) } + constructors
+            class_method_names = Set.new(class_methods.map(&:name))
+            parent_meths = parent_methods(visibility: visibility).reject { |m| class_method_names.include?(m.name) }
+            class_methods + parent_meths
+          end
+        end
+
+        # @return [String]
+        def path
+          "#{namespace.path}.#{namespace.type == :class ? 'class' : 'module'}"
+        end
+
+        def namespace
+          namespace_object
+        end
+
+        # @param [String]
+        def docstring
+          namespace.docstring
+        end
+
+        # @return [Array<[String, Integer]>]
+        def defined_files
+          namespace.files
+        end
+
+        private
+
+        # @return [Array<Functions::Constructor>]
+        def constructors
+          [] unless namespace_object.type == :class
+          [] if namespace.child(name: :new, scope: :class)
+          [namespace.child(name: :initialize, scope: :instance)].map do |method_object|
+            Functions::Constructor.new(method_object)
+          end
+        end
+
+        # @return [Array<Functions::Base>]
+        def parent_methods(visibility: nil)
+          case namespace_object.type
+          when :class
+            InstanceValue.new(registry, registry.find_or_proxy('::Class')).methods(visibility: visibility)
+          when :module
+            InstanceValue.new(registry, registry.find_or_proxy('::Module')).methods(visibility: visibility)
+          else
+            []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing.rb

@@ -0,0 +1,15 @@
+module Yoda
+  module Parsing
+    require 'yoda/parsing/ast_traversable'
+    require 'yoda/parsing/comment_tokenizer'
+    require 'yoda/parsing/parser'
+    require 'yoda/parsing/source_analyzer'
+    require 'yoda/parsing/node_objects'
+    require 'yoda/parsing/location'
+    require 'yoda/parsing/scopes'
+    require 'yoda/parsing/source_cutter'
+    require 'yoda/parsing/range'
+    require 'yoda/parsing/query'
+    require 'yoda/parsing/type_parser'
+  end
+end

data/lib/yoda/parsing/ast_traversable.rb

@@ -0,0 +1,18 @@
+module Yoda
+  module Parsing
+    module AstTraversable
+      # @param root_node [Array<::Parser::AST::Node>]
+      # @param current_location [Parser::Source::Map]
+      # @return [Array<::Parser::AST::Node>]
+      def calc_nodes_to_current_location(root_node, current_location)
+        nodes = [root_node]
+        node = root_node
+        while node && !node.children.empty?
+          node = node.children.find { |n| n.respond_to?(:location) && current_location.included?(n.location) }
+          nodes << node if node && node.is_a?(::Parser::AST::Node)
+        end
+        nodes
+      end
+    end
+  end
+end

data/lib/yoda/parsing/comment_tokenizer.rb

@@ -0,0 +1,59 @@
+require 'parslet'
+
+module Yoda
+  module Parsing
+    class CommentTokenizer
+      # @return [Sequence]
+      def parse(str)
+        Generator.new.apply(Tokenizer.new.parse(str))
+      end
+
+      class Tokenizer < Parslet::Parser
+        rule(:space) { match('\s').repeat(1) }
+        rule(:space?) { space.maybe }
+
+        rule(:comment_begin) { str('#') }
+        rule(:tag) { str('@') >> (str('!').maybe >> match('[a-zA-Z0-9_-]').repeat) }
+
+        rule(:name) { (sign.absent? >> match['[:graph:]']).repeat(1) }
+        rule(:sign) { match['\[\]<>,{}\(\)'] }
+
+        rule(:comment_token) { sign | name }
+
+        rule(:base) { comment_begin.maybe >> space? >> tag.maybe.as(:tag) >> space? >> (comment_token.as(:token) >> space?).repeat.as(:tokens) }
+        root :base
+      end
+
+      class Generator < Parslet::Transform
+        rule(token: simple(:token)) { token }
+        rule(tag: simple(:tag), tokens: sequence(:tokens)) { Sequence.new(tag: tag, tokens: tokens) }
+        rule(tag: simple(:tag), tokens: simple(:token)) { Sequence.new(tag: tag, tokens: [token]) }
+      end
+
+      class Sequence
+        # @type Parslet::Slice | nil
+        attr_reader :tag
+
+        # @param tag [Parslet::Slice, nil]
+        # @param tokens [Array<Parslet::Slice>]
+        def initialize(tag: nil, tokens: [])
+          fail ArgumentError, tag if tag && !tag.is_a?(Parslet::Slice)
+          fail ArgumentError, tokens unless tokens.all? { |token| token.is_a?(Parslet::Slice) }
+
+          @tag = tag
+          @tokens = tokens
+        end
+
+        # @return [Array<Parslet::Slice>]
+        def all_tokens
+          @all_tokens ||= [@tag, *parameter_tokens].compact
+        end
+
+        # @return [Array<Parslet::Slice>]
+        def parameter_tokens
+          @tokens
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/location.rb

@@ -0,0 +1,101 @@
+module Yoda
+  module Parsing
+    class Location
+      include Comparable
+
+      # @todo Make this 0-indexed.
+      # @return [Integer] 0-indexed column number.
+      attr_reader :row
+
+      # @return [Integer] 0-indexed column number.
+      attr_reader :column
+
+      # @param row    [Integer] 1-indexed row number.
+      # @param column [Integer] 0-indexed column number.
+      def initialize(row:, column:)
+        @row = row
+        @column = column
+      end
+
+      # @param ast_location [Parser::Source::Map, Parser::Source::Range]
+      # @return [Location, nil]
+      def self.of_ast_location(ast_location)
+        return nil unless valid_location?(ast_location)
+        Location.new(row: ast_location.line, column: ast_location.column)
+      end
+
+      # @param line    [Integer]
+      # @param character [Integer]
+      # @return [Location]
+      def self.of_language_server_protocol_position(line:, character:)
+        new(row: line + 1, column: character)
+      end
+
+      # @param location [Parser::Source::Range, Parser::Source::Map, Object]
+      def self.valid_location?(location)
+        return false if !location.is_a?(::Parser::Source::Range) && !location.is_a?(::Parser::Source::Map)
+        return false if location.is_a?(::Parser::Source::Map) && !location.expression
+        true
+      end
+
+      # @param location [Parser::Source::Range, Parser::Source::Map]
+      def index_of(source)
+        (source.split("\n").slice(0, row - 1) || []).map(&:length).reduce(0, &:+) + column
+      end
+
+      # @param location [Parser::Source::Range, Parser::Source::Map]
+      def included?(location)
+        return false unless self.class.valid_location?(location)
+        after_begin(location) && before_last(location)
+      end
+
+      # @param location [Parser::Source::Range, Parser::Source::Map]
+      def later_than?(location)
+        move(row: 0, column: -1).after_begin(location)
+      end
+
+      # @param location [Parser::Source::Range, Parser::Source::Map]
+      def after_begin(location)
+        return false unless self.class.valid_location?(location)
+        (location.line == row && location.column <= column) || location.line < row
+      end
+
+      # @param location [Parser::Source::Range, Parser::Source::Map]
+      def before_last(location)
+        return false unless self.class.valid_location?(location)
+        (location.last_line == row && column <= location.last_column ) || row < location.last_line
+      end
+
+      # @param location [Parser::Source::Range, Parser::Source::Map]
+      # @return [{Symbol => Numerical}]
+      def offset_from_begin(location)
+        fail ArgumentError, location unless self.class.valid_location?(location)
+        { line: row - location.line, column: column - location.column }
+      end
+
+      # @param row    [Integer]
+      # @param column [Integer]
+      # @return [Location]
+      def move(row:, column:)
+        self.class.new(row: @row + row, column: @column + column)
+      end
+
+      # @return [{Symbol => Integer}]
+      def to_language_server_protocol_range
+        { line: row - 1, character: column }
+      end
+
+      def to_s
+        "(#{row}, #{column})"
+      end
+
+      # @param another [Location]
+      # @return [Integer]
+      def <=>(another)
+        return 0 if row == another.row && column == another.column
+        return 1 if (row == another.row && column >= another.column) || row > another.row
+        -1
+      end
+    end
+  end
+end

data/lib/yoda/parsing/node_objects.rb

@@ -0,0 +1,10 @@
+module Yoda
+  module Parsing
+    module NodeObjects
+      require 'yoda/parsing/node_objects/const_node'
+      require 'yoda/parsing/node_objects/send_node'
+      require 'yoda/parsing/node_objects/method_definition'
+      require 'yoda/parsing/node_objects/namespace'
+    end
+  end
+end

data/lib/yoda/parsing/node_objects/const_node.rb

@@ -0,0 +1,52 @@
+module Yoda
+  module Parsing
+    module NodeObjects
+      class ConstNode
+        # @param node [::AST::Node]
+        attr_reader :node
+
+        # @param node [::AST::Node]
+        def initialize(node)
+          fail ArgumentError, node unless node.is_a?(::AST::Node) && node.type == :const
+          @node = node
+        end
+
+        # @return [ConstNode, nil]
+        def parent_const
+          node.children.first && node.children.first.type == :const ? ConstNode.new(node.children.first) : nil
+        end
+
+        # @return [true, false]
+        def absolute?
+          node.children.first == :cbase
+        end
+
+        # @param location [Location]
+        # @return [true, false]
+        def just_after_separator?(location)
+          return false unless node.location.double_colon
+          location == Location.of_ast_location(node.location.double_colon.end)
+        end
+
+        # @return [Model::Path]
+        def to_path
+          Model::Path.new(to_s)
+        end
+
+        # @param base [String, Symbol, nil]
+        # @return [String]
+        def to_s(base = nil)
+          fail ArgumentError, base unless !base || base.is_a?(String) || base.is_a?(Symbol)
+          paths = []
+          looking_node = node
+          while true
+            return (base ? base.to_s + '::' : '') + paths.join('::') unless looking_node
+            return '::' + paths.join('::') if looking_node.type == :cbase
+            paths.unshift(looking_node.children[1])
+            looking_node = looking_node.children[0]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/node_objects/method_definition.rb

@@ -0,0 +1,46 @@
+module Yoda
+  module Parsing
+    module NodeObjects
+      class MethodDefinition
+
+        # @return [::Parser::AST::Node]
+        attr_reader :node
+
+        # @return [Namespace]
+        attr_reader :namespace
+
+        # @param node [::Parser::AST::Node]
+        # @param namespace [Namespace]
+        def initialize(node, namespace)
+          fail ArgumentError, node unless node.is_a?(::Parser::AST::Node)
+          fail ArgumentError, namespace unless namespace.is_a?(Namespace)
+          @node = node
+          @namespace = namespace
+        end
+
+        # @return [Symbol]
+        def name
+          node.children[-3]
+        end
+
+        def arg_node
+          node.children[-2]
+        end
+
+        def body_node
+          node.children[-1]
+        end
+
+        # @return [String]
+        def full_name
+          "#{namespace.full_name}##{name}"
+        end
+
+        # @return [String]
+        def namespace_name
+          namespace.full_name
+        end
+      end
+    end
+  end
+end

data/lib/yoda/parsing/node_objects/namespace.rb

@@ -0,0 +1,104 @@
+module Yoda
+  module Parsing
+    module NodeObjects
+      class Namespace
+        include AstTraversable
+
+        # @return [::Parser::AST::Node]
+        attr_reader :node
+
+        # @return [Namespace, nil]
+        attr_reader :parent
+
+        # @param node [::Parser::AST::Node]
+        # @param parent [Namespace, nil]
+        def initialize(node, parent = nil)
+          fail ArgumentError, node unless node.is_a?(::Parser::AST::Node)
+          fail ArgumentError, parent unless !parent || parent.is_a?(Namespace)
+          @node = node
+          @parent = parent
+        end
+
+        # @return [::Parser::AST::Node]
+        def body_node
+          return node if type == :root
+          return node.children[2] if type == :class
+          node.children[1]
+        end
+
+        # @return [::Parser::AST::Node, nil]
+        def const_node
+          %i(root sclass).include?(type) ? nil : node.children[0]
+        end
+
+        # @return [Namespace]
+        def child_namespaces
+          @child_namespaces ||= child_nodes_of(body_node).select { |node| %i(module class sclass).include?(node.type) }.map { |node| self.class.new(node, self) }
+        end
+
+        # @return [Wrappers::MethodNodeWrapper]
+        def child_methods
+          @child_methods ||= child_nodes_of(body_node).select { |node| %i(def defs).include?(node.type) }.map { |node| MethodDefinition.new(node, self) }
+        end
+
+        def type
+          @type ||= begin
+            return node.type if %i(module class sclass).include?(node.type)
+            :root
+          end
+        end
+
+        # @return [String]
+        def path
+          name = full_name
+          name == :root ? '' : name
+        end
+
+        # @return [true, false]
+        def root?
+          type == :root
+        end
+
+        # @return [String, Symbol]
+        def full_name
+          return :root if type == :root
+          parent_name = parent && !parent.root? ? parent.full_name : ''
+          const_node ? ConstNode.new(const_node).to_s(parent_name) : parent_name
+        end
+
+        # @return [Array<String>]
+        def paths_from_root
+          if root?
+            [path]
+          else
+            parent ? parent.paths_from_root + [path] : ['', path]
+          end
+        end
+
+        # @param location [Location]
+        # @return [Namespace, nil]
+        def calc_current_location_namespace(location)
+          return nil unless location.included?(node.location)
+          including_child_namespace = child_namespaces.find { |namespace| location.included?(namespace.node.location) }
+          including_child_namespace ? including_child_namespace.calc_current_location_namespace(location) : self
+        end
+
+        # @param location [Location]
+        # @return [MethodNodeWrapper, nil]
+        def calc_current_location_method(location)
+          namespace = calc_current_location_namespace(location)
+          namespace && namespace.child_methods.find { |method| location.included?(method.node.location) }
+        end
+
+        private
+
+        def child_nodes_of(node)
+          # @todo evaluate nodes in the namespace
+          return [] unless node
+          return node.children.map { |child| child_nodes_of(child) }.flatten.compact if node.type == :begin
+          [node]
+        end
+      end
+    end
+  end
+end