yoda-language-server 0.4.0

data/lib/yoda/store/query/find_meta_class.rb

@@ -0,0 +1,18 @@
+module Yoda
+  module Store
+    module Query
+      class FindMetaClass < Base
+        # @param path [String, Model::Path, Model::ScopedPath]
+        # @return [Objects::NamespaceObject, nil]
+        def find(path)
+          constant = FindConstant.new(registry).find(path)
+          if constant && meta_class = registry.find(Objects::MetaClassObject.address_of(constant.path))
+            meta_class
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/query/find_method.rb

@@ -0,0 +1,74 @@
+module Yoda
+  module Store
+    module Query
+      class FindMethod < Base
+        # @param namespace [Objects::Namespace]
+        # @param method_name [String, Regexp]
+        # @param visibility [Array<Symbol>, nil]
+        # @return [Objects::MethodObject, nil]
+        def find(namespace, method_name, visibility: nil)
+          lazy_select(namespace, method_name, visibility: visibility).first
+        end
+
+        # @param namespace [Objects::Namespace]
+        # @param method_name [String, Regexp]
+        # @param visibility [Array<Symbol>, nil]
+        # @return [Array<Objects::MethodObject>]
+        def select(namespace, method_name, visibility: nil)
+          lazy_select(namespace, method_name, visibility: nil).to_a
+        end
+
+        private
+
+        # @param namespace [Objects::Namespace]
+        # @param expected [String, Regexp]
+        # @param visibility [Array<Symbol>, nil]
+        # @return [Enumerator<Objects::MethodObject>]
+        def lazy_select(namespace, expected, visibility: nil)
+          visibility ||=  %i(public private protected)
+          Enumerator.new do |yielder|
+            met = Set.new
+
+            all_method_addresses(namespace).each do |address|
+              name = Objects::MethodObject.name_of_path(address)
+              if match_name?(name, expected)
+                next if met.include?(name)
+                if el = registry.find(address)
+                  met.add(name)
+                  yielder << el if visibility.include?(el.visibility)
+                end
+              end
+            end
+          end
+        end
+
+        # @param namespace [Objects::Namespace]
+        # @return [Enumerator<Objects::MethodObject>]
+        def all_method_addresses(namespace)
+          Enumerator.new do |yielder|
+            Associators::AssociateAncestors.new(registry).associate(namespace)
+            namespace.ancestors.each do |ancestor|
+              ancestor.instance_method_addresses.each do |address|
+                yielder << address
+              end
+            end
+          end
+        end
+
+        # @param name [String]
+        # @param expected_name_or_pattern [String, Regexp]
+        # @return [true, false]
+        def match_name?(name, expected_name_or_pattern)
+          case expected_name_or_pattern
+          when String
+            name == expected_name_or_pattern
+          when Regexp
+            name.match?(expected_name_or_pattern)
+          else
+            fail ArgumentError, expected_name_or_pattern
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/query/find_signature.rb

@@ -0,0 +1,43 @@
+module Yoda
+  module Store
+    module Query
+      class FindSignature < Base
+        # @param namespace [Objects::NamespaceObject]
+        # @param method_name [String, Regexp]
+        # @param visibility [Array<Symbol>, nil]
+        # @return [Array<Objects::MethodObject>]
+        def select(namespace, method_name, visibility: nil)
+          FindMethod.new(registry).select(namespace, method_name, visibility: visibility).map { |el| build(namespace, el) }.flatten
+        end
+
+        private
+
+        # @param receiver [Store::Objects::NamespaceObject]
+        # @param method_object [Store::Objects::MethodObject]
+        # @return [Array<FunctionSignatures::Base>]
+        def build(receiver, method_object)
+          if constructor = try_to_build_constructor(receiver, method_object)
+            [constructor]
+          elsif method_object.overloads.empty?
+            [Model::FunctionSignatures::Method.new(method_object)]
+          else
+            method_object.overloads.map { |overload| Model::FunctionSignatures::Overload.new(method_object, overload) }
+          end
+        end
+
+        # @param receiver [Store::Objects::NamespaceObject]
+        # @param method_object [Store::Objects::MethodObject]
+        # @return [FunctionSignatures::Constructor, nil]
+        def try_to_build_constructor(receiver, method_object)
+          if method_object.path == 'Class#new' && receiver.is_a?(Store::Objects::MetaClassObject) && receiver.path != 'Class'
+            base_class = registry.find(receiver.base_class_address) || return
+            initialize_object = FindMethod.new(registry).find(base_class, 'initialize') || return
+            Model::FunctionSignatures::Constructor.new(base_class, initialize_object)
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/registry.rb

@@ -0,0 +1,67 @@
+require 'yard'
+require 'ruby-progressbar'
+
+module Yoda
+  module Store
+    class Registry
+      # @return [Adapters::LmdbAdapter, nil]
+      attr_reader :adapter
+
+      # @param adapter [Adapters::LmdbAdapter]
+      attr_writer :adapter
+
+      # @return [Objects::PatchSet]
+      attr_reader :patch_set
+
+      def initialize(adapter = nil)
+        @patch_set = Objects::PatchSet.new
+        @adapter = adapter
+      end
+
+      # @param path [String]
+      # @return [Objects::Base, nil]
+      def find(path)
+        if adapter&.exist?(path)
+          patch_set.patch(adapter.get(path))
+        else
+          patch_set.find(path)
+        end
+      end
+
+      # @param patch [Patch]
+      def add_patch(patch)
+        patch_set.register(patch)
+      end
+
+      # @param path [String]
+      # @return [true, false]
+      def has_key?(path)
+        adapter&.exists?(path) || patch_set.has_key?(path)
+      end
+
+      # Store patch set data to the database.
+      # old data in the database are discarded.
+      # @param progress [true, false]
+      def compress_and_save(progress: false)
+        return unless adapter
+        el_keys = patch_set.keys
+        bar = ProgressBar.create(format: " %c/%C |%w>%i| %e ", total: el_keys.length) if progress
+
+        data = Enumerator.new do |yielder|
+          el_keys.each { |key| yielder << [key, patch_set.find(key)] }
+        end
+
+        adapter.batch_write(data, bar)
+        adapter.sync
+        STDERR.puts "saved #{el_keys.length} keys."
+        @patch_set = Objects::PatchSet.new
+      end
+
+      private
+
+      def keys
+        Set.new(adapter&.keys.map(&:to_s) || []).union(patch_set.keys)
+      end
+    end
+  end
+end

data/lib/yoda/store/yard_importer.rb

@@ -0,0 +1,260 @@
+require 'yard'
+
+module Yoda
+  module Store
+    class YardImporter
+      # @return [Objects::Patch]
+      attr_reader :patch
+
+      # @return [String, nil]
+      attr_reader :root_path
+
+      # @param file [String]
+      # @param root_path [String, nil]
+      # @return [Objects::Patch]
+      def self.import(file, root_path: nil)
+        store = YARD::RegistryStore.new
+        store.load(file)
+        root_path ||= File.expand_path('..', file)
+        new(file, root_path: root_path).import(store.values).patch
+      end
+
+      # @param id [String]
+      def initialize(id, root_path: nil)
+        @patch = Objects::Patch.new(id)
+        @root_path = root_path
+        @registered = Set.new
+      end
+
+      # @param values [Array<YARD::CodeObjects::Base>]
+      # @return [self]
+      def import(values)
+        values.each do |el|
+          register(el)
+        end
+        self
+      end
+
+      # @param code_object [YARD::CodeObjects::Base]
+      def register(code_object)
+        return if @registered.member?(code_object.path)
+        @registered.add(code_object.path)
+        register(code_object.parent) if code_object.parent && !code_object.parent.root?
+
+        new_objects = begin
+          case code_object.type
+          when :root
+            convert_root_object(code_object)
+          when :class
+            convert_class_object(code_object)
+          when :module
+            convert_module_object(code_object)
+          when :classvariable
+            # convert_class_variable_object(code_object)
+          when :method
+            convert_method_object(code_object)
+          when :macro
+            # convert_macro_object(code_object)
+          when :constant
+            convert_constant_object(code_object)
+          when :proxy
+            create_proxy_module(code_object)
+          else
+            fail ArgumentError, 'Unsupported type code object'
+          end
+        end
+
+        register_to_parent_proxy(code_object) if code_object.parent && code_object.parent.type == :proxy
+        [new_objects].flatten.compact.each { |new_object| patch.register(new_object) }
+      end
+
+      private
+
+      # @param code_object [::YARD::CodeObjects::NamespaceObject]
+      # @return [Objects::ClassObject]
+      def convert_root_object(code_object)
+        # @todo Add meta class for main object.
+        Objects::ClassObject.new(
+          path: 'Object',
+          document: code_object.docstring.to_s,
+          tag_list: code_object.tags.map { |tag| convert_tag(tag, '') },
+          sources: code_object.files.map(&method(:convert_source)),
+          primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
+          instance_method_addresses: code_object.meths(included: false, scope: :instance).map(&:path),
+          mixin_addresses: code_object.instance_mixins.map { |mixin| mixin.path },
+          constant_addresses: (code_object.children.select{ |child| %i(constant module class).include?(child.type) }.map { |constant| constant.path } + ['Object']).uniq,
+        )
+      end
+
+      # @param code_object [::YARD::CodeObjects::ConstantObject]
+      # @return [Objects::ValueObject]
+      def convert_constant_object(code_object)
+        Objects::ValueObject.new(
+          path: code_object.path,
+          document: code_object.docstring.to_s,
+          tag_list: code_object.tags.map { |tag| convert_tag(tag, code_object.namespace.path) },
+          sources: code_object.files.map(&method(:convert_source)),
+          primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
+          value: code_object.value,
+        )
+      end
+
+      # @param code_object [::YARD::CodeObjects::MethodObject]
+      # @return [Objects::MethodObject, (Objects::MethodObject, Object::ClassObject)]
+      def convert_method_object(code_object)
+        if code_object.namespace.root?
+          # @todo Remove root oriented method path from Object namespace
+          method_object = Objects::MethodObject.new(
+            path: "Object#{code_object.sep}#{code_object.name}",
+            document: code_object.docstring.to_s,
+            tag_list: code_object.tags.map { |tag| convert_tag(tag, code_object.namespace.path) },
+            overloads: code_object.tags(:overload).map { |tag| convert_overload_tag(tag, code_object.namespace.path) },
+            sources: code_object.files.map(&method(:convert_source)),
+            primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
+            parameters: code_object.parameters,
+            visibility: :private,
+          )
+          object_object = Objects::ClassObject.new(
+            path: 'Object',
+            instance_method_addresses: ["Object#{code_object.sep}#{code_object.name}"],
+          )
+          [method_object, object_object]
+        else
+          Objects::MethodObject.new(
+            path: code_object.path,
+            document: code_object.docstring.to_s,
+            tag_list: code_object.tags.map { |tag| convert_tag(tag, code_object.namespace.path) },
+            overloads: code_object.tags(:overload).map { |tag| convert_overload_tag(tag, code_object.namespace.path) },
+            sources: code_object.files.map(&method(:convert_source)),
+            primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
+            parameters: code_object.parameters,
+            visibility: code_object.visibility,
+          )
+        end
+      end
+
+      # @param code_object [::YARD::CodeObjects::ModuleObject]
+      # @return [Array<Objects::ModuleObject, Objects::MetaClassObject>]
+      def convert_module_object(code_object)
+        module_object = Objects::ModuleObject.new(
+          path: code_object.path,
+          document: code_object.docstring.to_s,
+          tag_list: code_object.tags.map { |tag| convert_tag(tag, code_object.path) },
+          sources: code_object.files.map(&method(:convert_source)),
+          primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
+          instance_method_addresses: code_object.meths(included: false, scope: :instance).map(&:path),
+          mixin_addresses: code_object.instance_mixins.map { |mixin| mixin.path },
+          constant_addresses: code_object.children.select{ |child| %i(constant module class).include?(child.type) }.map { |constant| constant.path },
+        )
+
+        meta_class_object = Objects::MetaClassObject.new(
+          path: code_object.path,
+          sources: code_object.files.map(&method(:convert_source)),
+          primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
+          instance_method_addresses: code_object.meths(included: false, scope: :class).map(&:path),
+          mixin_addresses: code_object.instance_mixins.map { |mixin| mixin.path },
+        )
+
+        [module_object, meta_class_object]
+      end
+
+      # @param code_object [::YARD::CodeObjects::ClassObject]
+      # @return [Array<Objects::ClassObject, Objects::MetaClassObject>]
+      def convert_class_object(code_object)
+        class_object = Objects::ClassObject.new(
+          path: code_object.path,
+          document: code_object.docstring.to_s,
+          tag_list: code_object.tags.map { |tag| convert_tag(tag, code_object.path) },
+          sources: code_object.files.map(&method(:convert_source)),
+          primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
+          instance_method_addresses: code_object.meths(included: false, scope: :instance).map(&:path),
+          mixin_addresses: code_object.instance_mixins.map { |mixin| mixin.path },
+          constant_addresses: code_object.children.select{ |child| %i(constant module class).include?(child.type) }.map { |constant| constant.path },
+          superclass_path: code_object.superclass&.path == 'Qnil' ? nil : code_object.superclass&.path,
+        )
+
+        meta_class_object = Objects::MetaClassObject.new(
+          path: code_object.path,
+          sources: code_object.files.map(&method(:convert_source)),
+          primary_source: code_object[:current_file_has_comments] ? convert_source(code_object.files.first) : nil,
+          instance_method_addresses: code_object.meths(included: false, scope: :class).map(&:path),
+          mixin_addresses: code_object.class_mixins.map { |mixin| mixin.path },
+        )
+
+        [class_object, meta_class_object]
+      end
+
+      # @param tag [::YARD::Tags::Tag]
+      # @param namespace [String]
+      # @return [Objects::Tag]
+      def convert_tag(tag, namespace)
+        Objects::Tag.new(tag_name: tag.tag_name, name: tag.name, yard_types: tag.types, text: tag.text, lexical_scope: convert_to_lexical_scope(namespace))
+      end
+
+      # @param tag [::YARD::Tags::OverloadTag]
+      # @param namespace [String]
+      # @return [Objects::Tag]
+      def convert_overload_tag(tag, namespace)
+        Objects::Overload.new(name: tag.name.to_s, tag_list: tag.tags.map { |tag| convert_tag(tag, namespace) }, document: tag.docstring.to_s, parameters: tag.parameters)
+      end
+
+      # @param namespace [String]
+      # @return [Array<String>]
+      def convert_to_lexical_scope(namespace)
+        path = Model::Path.new(namespace)
+        ((path.to_s.empty? ? [] : [path]) + path.parent_paths).map(&:to_s)
+      end
+
+      # @param symbol [Symbol]
+      # @return [Symbol]
+      def convert_yard_object_type(type)
+        case type
+        when :constant
+          :value
+        else
+          type
+        end
+      end
+
+      # @param code_object [::YARD::CodeObjects::Proxy]
+      # @return [Array<Objects::ModuleObject>]
+      def create_proxy_module(code_object)
+        module_object = Objects::ModuleObject.new(
+          path: code_object.path,
+          document: '',
+          tag_list: [],
+          sources: [],
+          primary_source: nil,
+          instance_method_addresses: [],
+          mixin_addresses: [],
+          constant_addresses: [],
+        )
+
+        meta_class_object = Objects::MetaClassObject.new(
+          path: code_object.path,
+          sources: [],
+          primary_source: nil,
+          instance_method_addresses: [],
+          mixin_addresses: [],
+        )
+
+        [module_object, meta_class_object]
+      end
+
+      # @param code_object [::YARD::CodeObjects::Base]
+      # @return [vaid]
+      def register_to_parent_proxy(code_object)
+        proxy_module = patch.find(code_object.parent.path)
+        proxy_module.instance_method_addresses.push(code_object.path) if code_object.type == :method
+        proxy_module.constant_addresses.push(code_object.path) if [:class, :module, :proxy].include?(code_object.type)
+      end
+
+      # @param source [(String, Integer)]
+      # @return [(String, Integer, Integer)]
+      def convert_source(source)
+        file, line = source
+        [root_path ? File.expand_path(file, root_path) : file, line, 0]
+      end
+    end
+  end
+end