yoda-language-server 0.7.1 → 0.9.0

data/lib/yoda/store/objects/base.rb

@@ -1,3 +1,5 @@
+require 'yoda/store/objects/connected_delegation'
+
 module Yoda
   module Store
     module Objects
@@ -14,6 +16,51 @@ module Yoda
           end
         end
 
+        # A wrapper class of {Objects::Base} to allow access to registry.
+        class Connected
+          extend ConnectedDelegation
+
+          # @return [Base]
+          attr_reader :object
+          
+          # @return [Registry]
+          attr_reader :registry
+
+          delegate_to_object :address, :path, :document, :tag_list, :sources, :primary_source, :json_class, :to_json, :derive
+          delegate_to_object :name, :kind, :address, :parent_adderss, :to_h, :hash, :eql?, :==, :namespace?, :meta_class_address
+          
+          # @param object [Base]
+          # @param registry [Registry]
+          def initialize(object, registry:)
+            @object = object
+            @registry = registry
+          end
+
+          def with_connection(**kwargs)
+            if kwargs == connection_options
+              self
+            else
+              object.with_connection(**kwargs)
+            end
+          end
+
+          def merge(another)
+            object.merge(another).with_connection(**connection_options)
+          end
+          
+          # @return [Objects::MetaClassObject::Connected, nil]
+          def meta_class
+            registry.get(meta_class_address)&.with_connection(**connection_options)
+          end
+
+          private
+
+          # @return [Hash]
+          def connection_options
+            { registry: registry }
+          end
+        end
+
         # @return [String]
         attr_reader :path
 
@@ -31,7 +78,7 @@ module Yoda
 
         # @param path [String]
         # @param document [String]
-        # @param tag_list [TagList, nil]
+        # @param tag_list [Array<Tag>, nil]
         # @param sources [Array<(String, Integer, Integer)>]
         # @param primary_source [(String, Integer, Integer), nil]
         def initialize(path:, document: '', tag_list: [], sources: [], primary_source: nil, json_class: nil, kind: nil)
@@ -57,6 +104,19 @@ module Yoda
           path
         end
 
+        # @return [String]
+        def meta_class_address
+          MetaClassObject.address_of(address)
+        end
+
+        # @return [String]
+        def parent_address
+          @parent_address ||= begin
+            sliced_address = address.slice(0, (path.rindex('::') || 0))
+            sliced_address.empty? ? 'Object' : sliced_address
+          end
+        end
+
         # @return [Hash]
         def to_h
           {
@@ -65,14 +125,14 @@ module Yoda
             document: document,
             tag_list: tag_list,
             sources: sources,
-            primary_source: primary_source
+            primary_source: primary_source,
           }
         end
 
         # @param another [self]
         # @return [self]
         def merge(another)
-          self.class.new(merge_attributes(another))
+          Merger.new([self, another]).merged_instance
         end
 
         def hash
@@ -80,13 +140,22 @@ module Yoda
         end
 
         def eql?(another)
-          self.class == another.class && to_h == another.to_h
+          another.respond_to?(:kind) && self.kind == another.kind && to_h == another.to_h
         end
 
         def ==(another)
           eql?(another)
         end
 
+        def namespace?
+          false
+        end
+
+        # @return [Connected]
+        def with_connection(**kwargs)
+          self.class.const_get(:Connected).new(self, **kwargs)
+        end
+
         private
 
         # @param another [self]

data/lib/yoda/store/objects/class_object.rb

@@ -2,7 +2,16 @@ module Yoda
   module Store
     module Objects
       class ClassObject < NamespaceObject
-        # @return [ScopedPath, nil]
+        class Connected < NamespaceObject::Connected
+          delegate_to_object :superclass_path
+
+          # @return [NamespaceObject::Connected]
+          def superclass
+            ancestor_tree.superclass.with_connection(**connection_options)
+          end
+        end
+
+        # @return [Path, nil]
         attr_reader :superclass_path
 
         # @return [Array<Symbol>]
@@ -13,9 +22,9 @@ module Yoda
         # @param path [String]
         # @param superclass_path [String, nil]
         def initialize(superclass_path: nil, **kwargs)
-          super(kwargs)
+          super(**kwargs)
 
-          @superclass_path = Model::ScopedPath.new(Objects.lexical_scopes_of(path), superclass_path) if superclass_path
+          @superclass_path = Model::Path.new(superclass_path) if superclass_path
         end
 
         def kind
@@ -23,7 +32,7 @@ module Yoda
         end
 
         def to_h
-          super.merge(superclass_path: superclass_path&.path&.to_s)
+          super.merge(superclass_path: superclass_path&.to_s)
         end
 
         private
@@ -32,14 +41,14 @@ module Yoda
         # @return [Hash]
         def merge_attributes(another)
           super.merge(
-            superclass_path: select_superclass(another.superclass_path)&.path&.to_s,
+            superclass_path: select_superclass(another.superclass_path)&.to_s,
           )
         end
 
         # @param another [ScopedPath]
-        # @return [ScopedPath]
+        # @return [Path]
         def select_superclass(another)
-          if %w(Object Exception).include?(another&.path&.to_s)
+          if %w(Object Exception).include?(another&.to_s)
             superclass_path || another
           else
             another || superclass_path

data/lib/yoda/store/objects/connected_delegation.rb

@@ -0,0 +1,25 @@
+module Yoda
+  module Store
+    module Objects
+      module ConnectedDelegation
+        # @param method_names [Array<Symbol>]
+        # @return [void]
+        def delegate_to_object(*method_names)
+          if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7.0')
+            method_names.each do |method_name|
+              define_method(method_name) do |*args, **kwargs|
+                object.public_send(method_name, *args, **kwargs)
+              end
+            end
+          else
+            method_names.each do |method_name|
+              define_method(method_name) do |*args|
+                object.public_send(method_name, *args)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/objects/libraries_status.rb

@@ -0,0 +1,67 @@
+module Yoda
+  module Store
+    module Objects
+      class LibrariesStatus
+        include Serializable
+
+        # @return [Array<CoreStatus, StdStatus, GemStatus, LocalLibraryStatus>]
+        attr_reader :libraries
+
+        # @param dependency [Project::Dependency]
+        # @return [Array<Object::Library::Core, Object::Library::Std, Object::Library::Gem>]
+        def self.libraies_from_dependency(dependency)
+          [dependency.core, dependency.std, *dependency.gems.select(&:installed?)]
+        end
+
+        # @param libraries [Array<Library::Core, Library::Std, Library::Gem>]
+        def initialize(libraries: [])
+          @libraries = libraries
+        end
+
+        def add_library(library)
+          @libraries.push(library)
+        end
+
+        def remove_library(library)
+          @libraries.delete_if { |lib| lib.id == library.id }
+        end
+
+        def to_h
+          { libraries: libraries }
+        end
+
+        # @return [Connected]
+        def with_project_connection(**kwargs)
+          self.class.const_get(:Connected).new(self, **kwargs)
+        end
+
+        class Connected
+          extend ConnectedDelegation
+
+          delegate_to_object :to_h, :with_project_connection, :add_library, :remove_library
+          delegate_to_object :hash, :eql?, :==, :to_json, :derive
+
+          attr_reader :object, :project
+
+          # @param object [LibrariesStatus]
+          # @param project [Project]
+          def initialize(object, project:)
+            @object = object
+            @project = project
+          end
+
+          # @return [Array<Library::Core::Connected, Library::Std::Connected, Library::Gem::Connected>]
+          def libraries
+            object.libraries.map { |library| library.with_project_connection(project: project) }
+          end
+
+
+          # @return [Array<Registry::LibraryRegistry>]
+          def registries
+            libraries.map(&:registry).compact
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/objects/library/core.rb

@@ -0,0 +1,72 @@
+module Yoda
+  module Store
+    module Objects
+      module Library
+        class Core
+          include Serializable
+
+          # @return [String]
+          attr_reader :version
+
+          # @return [Core]
+          def self.current_version
+            new
+          end
+
+          # @param version [String]
+          def initialize(version: RUBY_VERSION)
+            @version = version
+          end
+
+          def to_h
+            { version: version }
+          end
+
+          def id
+            name
+          end
+
+          def name
+            'core'
+          end
+
+          def doc_path
+            VersionStore.for_current_version.core_yardoc_path
+          end
+
+          # @return [Connected]
+          def with_project_connection(**kwargs)
+            self.class.const_get(:Connected).new(self, **kwargs)
+          end
+
+          class Connected
+            extend ConnectedDelegation
+            include WithRegistry
+
+            delegate_to_object :version
+            delegate_to_object :id, :name, :doc_path, :to_h, :with_project_connection
+            delegate_to_object :hash, :eql?, :==, :to_json, :derive
+
+            attr_reader :object, :project
+
+            # @param object [Core]
+            # @param project [Project]
+            def initialize(object, project:)
+              @object = object
+              @project = project
+            end
+
+            def create_patch
+              Actions::ImportCoreLibrary.run(self)
+            end
+
+            # @note Implementation for {WithRegistry#registry_path}
+            def registry_path
+              VersionStore.for_current_version.registry_path_for_core
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/objects/library/gem.rb

@@ -0,0 +1,141 @@
+module Yoda
+  module Store
+    module Objects
+      module Library
+        class Gem
+          include Serializable
+
+          # @return [String]
+          attr_reader :name, :version, :source_path, :full_gem_path, :doc_dir
+
+          # @return [Symbol, nil]
+          attr_reader :source_type
+
+          class << self
+            # @param spec [Bundler::LazySpecification]
+            def from_gem_spec(spec)
+              if spec.respond_to?(:full_gem_path)
+                # Installed
+                new(
+                  name: spec.name,
+                  version: spec.version.version,
+                  source_path: spec.source.respond_to?(:path) ? spec.source.path : nil,
+                  full_gem_path: spec.full_gem_path,
+                  doc_dir: spec.doc_dir,
+                  source_type: source_type_of(spec.source),
+                )
+              else
+                # Not installed
+                new(
+                  name: spec.name,
+                  version: spec.version.version,
+                  source_path: nil,
+                  full_gem_path: nil,
+                  doc_dir: nil,
+                  source_type: nil,
+                )
+              end
+            end
+
+            # @param source [Bundler::Source, nil]
+            # @return [Symbol, nil]
+            def source_type_of(source)
+              return nil unless source
+
+              case source
+              when Bundler::Source::Git
+                :git
+              when Bundler::Source::Gemspec
+                :gemspec
+              when Bundler::Source::Rubygems
+                :rubygems
+              when Bundler::Source::Path
+                :path
+              else
+                nil
+              end
+            end
+          end
+
+          def initialize(name:, version:, source_path:, full_gem_path:, doc_dir:, source_type:)
+            @name = name
+            @version = version
+            @source_path = source_path
+            @full_gem_path = full_gem_path
+            @doc_dir = doc_dir
+            @source_type = source_type&.to_sym
+          end
+
+          def id
+            "#{name}:#{version}"
+          end
+
+          def local?
+            source_path
+          end
+
+          def to_h
+            {
+              name: name,
+              version: version,
+              source_path: source_path,
+              full_gem_path: full_gem_path,
+              doc_dir: doc_dir,
+              source_type: source_type,
+            }
+          end
+
+          # @return [Boolean]
+          def installed?
+            full_gem_path && File.exists?(full_gem_path)
+          end
+
+          def managed_by_rubygems?
+            source_type == :rubygems
+          end
+
+          # @return [Connected]
+          def with_project_connection(**kwargs)
+            self.class.const_get(:Connected).new(self, **kwargs)
+          end
+
+          class Connected
+            extend ConnectedDelegation
+            include WithRegistry
+
+            delegate_to_object :name, :version, :source_path, :full_gem_path, :doc_dir, :source_type
+            delegate_to_object :id, :local?, :to_h, :installed?, :managed_by_rubygems?, :with_project_connection
+            delegate_to_object :hash, :eql?, :==, :to_json, :derive
+
+            # @return [Gem]
+            attr_reader :object
+
+            # @return [Project]
+            attr_reader :project
+
+            # @param object [Gem]
+            # @param project [Project]
+            def initialize(object, project:)
+              @object = object
+              @project = project
+            end
+
+            # @note Implementation for {WithRegistry#registry_path}
+            def registry_path
+              if managed_by_rubygems?
+                project.library_registry_path(name: name, version: version)
+              else
+                # Do not persist not gems.
+                nil
+              end
+            end
+
+            def create_patch
+              Actions::ImportGem.run(self)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/objects/library/std.rb

@@ -0,0 +1,72 @@
+module Yoda
+  module Store
+    module Objects
+      module Library
+        class Std
+          include Serializable
+
+          # @return [String]
+          attr_reader :version
+
+          # @return [Core]
+          def self.current_version
+            new
+          end
+
+          # @param version [String]
+          def initialize(version: RUBY_VERSION)
+            @version = version
+          end
+
+          def to_h
+            { version: version }
+          end
+
+          def id
+            name
+          end
+
+          def name
+            'std'
+          end
+
+          def doc_path
+            VersionStore.for_current_version.stdlib_yardoc_path
+          end
+
+          # @return [Connected]
+          def with_project_connection(**kwargs)
+            self.class.const_get(:Connected).new(self, **kwargs)
+          end
+
+          class Connected
+            extend ConnectedDelegation
+            include WithRegistry
+
+            delegate_to_object :version
+            delegate_to_object :id, :name, :doc_path, :to_h, :with_project_connection
+            delegate_to_object :hash, :eql?, :==, :to_json, :derive
+
+            attr_reader :object, :project
+
+            # @param object [Core]
+            # @param project [Project]
+            def initialize(object, project:)
+              @object = object
+              @project = project
+            end
+
+            def create_patch
+              Actions::ImportStdLibrary.run(self)
+            end
+
+            # @note Implementation for {WithRegistry#registry_path}
+            def registry_path
+              VersionStore.for_current_version.registry_path_for_stdlib
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/objects/library/with_registry.rb

@@ -0,0 +1,28 @@
+module Yoda
+  module Store
+    module Objects
+      module Library
+        module WithRegistry
+          # @return [Boolean]
+          def registry_exists?
+            registry_path && File.exists?(registry_path)
+          end
+
+          # Return the path of registry for the library.
+          # @abstract
+          # @return [String, nil]
+          def registry_path
+            fail NotImplementedError
+          end
+
+          # @return [Registry::LibraryRegistry]
+          def registry
+            @registry ||= begin
+              Registry::LibraryRegistry.for_library(self)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/objects/library.rb

@@ -0,0 +1,24 @@
+module Yoda
+  module Store
+    module Objects
+      module Library
+        require 'yoda/store/objects/library/with_registry'
+        require 'yoda/store/objects/library/core'
+        require 'yoda/store/objects/library/std'
+        require 'yoda/store/objects/library/gem'
+
+        class << self
+          # @return [Core]
+          def core
+            Core.current_version
+          end
+
+          # @return [Std]
+          def std
+            Std.current_version
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/objects/map.rb

@@ -0,0 +1,61 @@
+module Yoda
+  module Store
+    module Objects
+      class Map
+
+        # @return [String]
+        attr_reader :path
+
+        # @return [Adapter]
+        attr_reader :adapter
+
+        # @return [Hash]
+        attr_reader :cache
+
+        # @return [Set]
+        attr_reader :updated_keys
+
+        # @param adapter [Adapters::Base]
+        # @param path [String]
+        def initialize(adapter:, path:)
+          @adapter = adapter
+          @path = path
+          @cache = {}
+          @updated_keys = Set.new
+        end
+
+        def separator
+          '::'
+        end
+
+        def []=(key, value)
+          updated_keys.add(key.to_sym)
+          cache[key.to_sym] = value
+        end
+
+        def [](key)
+          cache.fetch(key.to_sym) do
+            cache[key.to_sym] = adapter.get(path_for(key))
+          end
+        end
+
+        def save
+          updated_keys.each do |key|
+            adapter.put(path_for(key), self[key.to_sym])
+          end
+        end
+
+        def keys
+          @adapter_keys ||= adapter.keys.select { |key| key.start_with?("#{path}#{separator}") }.map { |key| key.slice(("#{path}#{separator}".length)..-1).to_sym }
+          Set.new(@adapter_keys) + updated_keys
+        end
+
+        private
+
+        def path_for(key)
+          "#{path}#{separator}#{key}"
+        end
+      end
+    end
+  end
+end