yoda-language-server 0.4.0

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

@@ -0,0 +1,45 @@
+module Yoda
+  module Store
+    module Objects
+      class ValueObject < Base
+        # @return [String]
+        attr_reader :value
+
+        # @return [Array<Symbol>]
+        def self.attr_names
+          super + %i(value)
+        end
+
+        # @param path [String]
+        # @param value [String]
+        def initialize(value: nil, **kwargs)
+          super(kwargs)
+          @value = value
+        end
+
+        # @return [String]
+        def name
+          @name ||= path.match(MODULE_TAIL_PATTERN) { |md| md[1] || md[2] }
+        end
+
+        def kind
+          :value
+        end
+
+        def to_h
+          super.merge(value: value)
+        end
+
+        private
+
+        # @param another [self]
+        # @return [Hash]
+        def merge_attributes(another)
+          super.merge(
+            value: another.value || self.value,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/project.rb

@@ -0,0 +1,159 @@
+require 'bundler'
+require 'tmpdir'
+require 'fileutils'
+require 'digest'
+
+module Yoda
+  module Store
+    class Project
+      # @type String
+      attr_reader :root_path
+
+      # @type Registry
+      attr_reader :registry
+
+      # @param root_path [String]
+      def initialize(root_path)
+        fail ArgumentError, root_path unless root_path.is_a?(String)
+
+        @root_path = File.absolute_path(root_path)
+        @registry = Registry.new
+      end
+
+      def clean
+      end
+
+      def setup
+        YARD::Logger.instance(STDERR)
+        make_dir
+        cache.setup
+        load_project_files
+        self
+      end
+
+      def rebuild_cache(progress: false)
+        make_dir
+        cache.build(progress: progress)
+      end
+
+      # @param source_path [String]
+      def read_source(source_path)
+        Actions::ReadFile.run(registry, source_path)
+      end
+
+      def yoda_dir
+        File.expand_path('.yoda', root_path)
+      end
+
+      private
+
+      def make_dir
+        File.exist?(yoda_dir) || FileUtils.mkdir(yoda_dir)
+      end
+
+      def load_project_files
+        Actions::ReadProjectFiles.new(registry, root_path).run
+      end
+
+      def cache
+        @cache ||= Cache.new(self)
+      end
+
+      class Cache
+        class Builder
+          # @return [Registry]
+          attr_reader :registry
+
+          # @return [String]
+          attr_reader :root_path
+
+          # @return [String]
+          attr_reader :gemfile_lock_path
+
+          def initialize(registry, root_path, gemfile_lock_path)
+            @registry = registry
+            @root_path = root_path
+            @gemfile_lock_path = gemfile_lock_path
+          end
+
+          def run(progress: false)
+            Actions::ImportCoreLibrary.new(registry).run
+            if File.exist?(gemfile_lock_path)
+              Actions::ImportGems.new(registry, gemfile_lock_parser.specs).run
+            end
+            registry.compress_and_save(progress: progress)
+          end
+
+          def gemfile_lock_parser
+            Dir.chdir(root_path) do
+              Bundler::LockfileParser.new(File.read(gemfile_lock_path))
+            end
+          end
+        end
+
+        # @return [Project]
+        attr_reader :project
+
+        def initialize(project)
+          @project = project
+        end
+
+        def build(progress: false)
+          STDERR.puts 'Constructing database for the current project.'
+          YARD::Logger.instance(STDERR)
+          make_cache_dir
+          register_adapter
+          project.registry.adapter.clear
+          Builder.new(project.registry, project.root_path, gemfile_lock_path).run(progress: progress)
+          STDERR.puts 'Finished to construct database for the current project.'
+        end
+
+        def setup
+          if present?
+            register_adapter
+          else
+            build
+          end
+        end
+
+        private
+
+        # @return [true, false]
+        def present?
+          File.exist?(cache_path)
+        end
+
+        def register_adapter
+          return if project.registry.adapter
+          project.registry.adapter = Adapters.default_adapter_class.for(cache_path)
+        end
+
+        def cache_dir
+          File.expand_path('cache', project.yoda_dir)
+        end
+
+        def cache_name
+          @cache_path ||= begin
+            digest = Digest::SHA256.new
+            digest.file(gemfile_lock_path) if File.exist?(gemfile_lock_path)
+            digest.update(Yoda::VERSION)
+            digest.update(Adapters.default_adapter_class.type.to_s)
+            digest.hexdigest
+          end
+        end
+
+        def cache_path
+          File.expand_path(cache_name, cache_dir)
+        end
+
+        def make_cache_dir
+          File.exist?(cache_dir) || FileUtils.mkdir_p(cache_dir)
+        end
+
+        def gemfile_lock_path
+          File.absolute_path('Gemfile.lock', project.root_path)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/query.rb

@@ -0,0 +1,12 @@
+module Yoda
+  module Store
+    module Query
+      require 'yoda/store/query/base'
+      require 'yoda/store/query/find_constant'
+      require 'yoda/store/query/find_meta_class'
+      require 'yoda/store/query/find_method'
+      require 'yoda/store/query/find_signature'
+      require 'yoda/store/query/associators'
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Yoda
+  module Store
+    module Query
+      module Associators
+        require 'yoda/store/query/associators/associate_ancestors'
+        require 'yoda/store/query/associators/associate_methods'
+      end
+    end
+  end
+end

data/lib/yoda/store/query/associators/associate_ancestors.rb

@@ -0,0 +1,103 @@
+require 'set'
+
+module Yoda
+  module Store
+    module Query
+      module Associators
+        class AssociateAncestors
+          class CircularReferenceError < StandardError; end
+
+          # @return [Registry]
+          attr_reader :registry
+
+          # @param registry [Registry]
+          def initialize(registry)
+            @registry = registry
+          end
+
+          # @param obj [Objects::Base]
+          def associate(obj)
+            if obj.is_a?(Objects::NamespaceObject)
+              obj.ancestors = Enumerator.new do |yielder|
+                Processor.new(registry).process(obj).each { |klass| yielder << klass }
+              end
+            end
+          end
+
+          private
+
+          class Processor
+            # @return [Registry]
+            attr_reader :registry
+
+            # @param registry [Registry]
+            def initialize(registry)
+              @registry = registry
+            end
+
+
+            # @return [Set<Objects::Base>]
+            def met
+              @met ||= Set.new
+            end
+
+            # @param scope [Objects::NamespaceObject]
+            # @return [Enumerator<Objects::NamespaceObject>]
+            def process(scope)
+              fail CircularReferenceError, scope if met.include?(scope)
+              met.add(scope)
+
+              Enumerator.new do |yielder|
+                if scope.is_a?(Objects::NamespaceObject)
+                  yielder << scope
+                  find_mixins(scope).each { |mixin| yielder << mixin }
+
+                  if scope.is_a?(Objects::MetaClassObject)
+                    find_metaclass_superclass_ancestors(scope).each { |obj| yielder << obj }
+                  elsif scope.is_a?(Objects::ClassObject)
+                    find_superclass_ancestors(scope).each { |obj| yielder << obj }
+                  end
+                end
+              end
+            end
+
+            # @param obj [Objects::NamespaceObject]
+            # @return [Enumerator<Objects::NamespaceObject>]
+            def find_mixins(obj)
+              Enumerator.new do |yielder|
+                obj.mixin_addresses.each do |address|
+                  if el = registry.find(address.to_s)
+                    yielder << el
+                  end
+                end
+              end
+            end
+
+            # @param obj [Objects::ClassObject]
+            # @return [Enumerator<Objects::NamespaceObject>]
+            def find_superclass_ancestors(obj)
+              if obj.superclass_path && super_class = FindConstant.new(registry).find(obj.superclass_path)
+                process(super_class)
+              else
+                []
+              end
+            end
+
+            # @param obj [Objects::MetaClassObject]
+            # @return [Enumerator<Objects::NamespaceObject>]
+            def find_metaclass_superclass_ancestors(obj)
+              base_class = registry.find(obj.base_class_address)
+              if base_class && base_class.is_a?(Objects::ClassObject) && base_class.superclass_path
+                (meta_class = FindMetaClass.new(registry).find(base_class.superclass_path || 'Object')) ? process(meta_class) : []
+              elsif base_class
+                (class_object = registry.find('Class')) ? process(class_object) : []
+              else
+                []
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/query/associators/associate_methods.rb

@@ -0,0 +1,38 @@
+module Yoda
+  module Store
+    module Query
+      module Associators
+        class AssociateMethods
+          # @return [Registry]
+          attr_reader :registry
+
+          # @param registry [Registry]
+          def initialize(registry)
+            @registry = registry
+          end
+
+          # @param obj [Object::Base]
+          def associate(obj)
+            if obj.is_a?(Objects::NamespaceObject)
+              AssociateMethods.new(registry).associate(obj)
+              obj.methods = Enumerator.new do |yielder|
+                name_set = Set.new
+
+                obj.ancestors.each do |ancestor|
+                  ancestor.instance_method_addresses.each do |method_address|
+                    method_name = Objects::MethodObject.name_of_path(method_address)
+                    next name_set.has_key?(method_name)
+                    name_set.add(method_name)
+                    if el = registry.find(method_address)
+                      yielder << el
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Yoda
+  module Store
+    module Query
+      # @abstract
+      class Base
+        # @return [Registry]
+        attr_reader :registry
+
+        # @param registry [Registry]
+        def initialize(registry)
+          @registry = registry
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+module Yoda
+  module Store
+    module Query
+      class FindConstant < Base
+        # @param path [String, Model::Path, Model::ScopedPath]
+        # @return [Objects::Base, nil]
+        def find(path)
+          lexical_scope_paths = lexical_scopes_of(path)
+          base_name, *constant_names = path_of(path).split
+          base_namespace = select_base_namespace(base_name, lexical_scope_paths).first
+
+          find_constant(constant_names.join('::'), base_namespace)
+        end
+
+        # @param path [String, Model::Path, Model::ScopedPath]
+        # @return [Array<Objects::Base>]
+        def select_with_prefix(path)
+          lexical_scope_paths = lexical_scopes_of(path)
+          base_name, *constant_names, bottom_name = path_of(path).split
+
+          if constant_names.empty? && !bottom_name
+            # When the path does not contain separator (`::`)
+            select_base_namespace(/\A#{Regexp.escape(base_name || '')}/, lexical_scope_paths).to_a.uniq
+          else
+            base_namespace = select_base_namespace(base_name, lexical_scope_paths).first
+            scope = find_constant(constant_names.join('::'), base_namespace)
+            return [] unless scope
+            select_constants_from_ancestors(scope, /\A#{bottom_name}/).to_a
+          end
+        end
+
+        private
+
+        # Find namespaces which matches with the lexical scopes and the unnested constant name.
+        #
+        # @param base_name [String, Regexp] is an unnested constant name or a pattern of unnested constant name.
+        # @param lexical_scope_paths [Array<String>]
+        # @return [Enumerator<Objects::Base>]
+        def select_base_namespace(base_name, lexical_scope_paths)
+          Enumerator.new do |yielder|
+            lexical_scope_paths.each do |path|
+              scope = find_constant(path.to_s)
+              next if !scope || !scope.is_a?(Objects::NamespaceObject)
+              select_child_constants(scope, base_name).each do |obj|
+                yielder << obj
+              end
+            end
+
+            nearest_scope_path = lexical_scope_paths.first
+            if nearest_scope_path && nearest_scope = find_constant(nearest_scope_path) && nearest_scope.is_a?(Objects::NamespaceObject)
+              select_constants_from_ancestors(nearest_scope, base_name).each do |obj|
+                yielder << obj
+              end
+            end
+          end
+        end
+
+        # @param name [String, Model::Path]
+        # @param namespace [Objects::Base, nil]
+        # @return [Objects::Base, nil]
+        def find_constant(name, namespace = nil)
+          constant_names = path_of(name).split
+          namespace = registry.find('Object') unless namespace
+          constant_names.reduce(namespace) do |namespace, name|
+            if namespace
+              select_constants_from_ancestors(namespace, name).first
+            else
+              return nil
+            end
+          end
+        end
+
+        # @param scope [Objects::NamespaceObject]
+        # @param name [String, Regexp]
+        # @return [Enumerator<Objects::Base>]
+        def select_constants_from_ancestors(scope, name)
+          Enumerator.new do |yielder|
+            met = Set.new
+
+            Associators::AssociateAncestors.new(registry).associate(scope)
+            scope.ancestors.each do |ancestor|
+              select_child_constants(ancestor, name).each do |obj|
+                next if met.include?(obj.name)
+                met.add(obj.name)
+                yielder << obj
+              end
+            end
+          end
+        end
+
+        # @param scope [Objects::Base]
+        # @param name [String, Regexp]
+        # @return [Enumerator<Objects::Base>]
+        def select_child_constants(scope, name)
+          Enumerator.new do |yielder|
+            if scope.is_a?(Objects::NamespaceObject)
+              scope.constant_addresses.select { |address| match_name?(Model::Path.new(address).basename, name) }.each do |address|
+                obj = registry.find(address)
+                yielder << obj if obj
+              end
+            end
+          end
+        end
+
+        # @param path [String, Model::Path, Model::ScopedPath]
+        # @return [Array<String>]
+        def lexical_scopes_of(path)
+          case path
+          when Model::Path
+            ['Object']
+          when Model::ScopedPath
+            if path.path.absolute?
+              ['Object']
+            else
+              path.scopes.map { |scope| scope.to_s.gsub(/\A::/, '') }
+            end
+          else
+            ['Object']
+          end
+        end
+
+        # @param path [String, Model::Path, Model::ScopedPath]
+        # @return [Model::Path]
+        def path_of(path)
+          case path
+          when Model::Path
+            path
+          when Model::ScopedPath
+            path.path
+          when String
+            Model::Path.new(path == '::' ? '::' : path.gsub(/\A::/, ''))
+          else
+            fail ArgumentError, path
+          end
+        end
+
+        # @param name [String]
+        # @param expected_name_or_pattern [String, Regexp]
+        # @return [true, false]
+        def match_name?(name, expected_name_or_pattern)
+          if expected_name_or_pattern.is_a?(String)
+            name == expected_name_or_pattern
+          else
+            name.match?(expected_name_or_pattern)
+          end
+        end
+      end
+    end
+  end
+end