yoda-language-server 0.4.0

data/lib/yoda/model/types/generic_type.rb

@@ -0,0 +1,66 @@
+module Yoda
+  module Model
+    module Types
+      class GenericType < Base
+        # @return [Base]
+        attr_reader :base_type
+
+        # @return [Array<Base>]
+        attr_reader :type_arguments
+
+        # @param base_type  [Base]
+        # @param key_type   [Base]
+        # @param value_type [Base]
+        def self.from_key_value(base_type, key_type, value_type)
+          new(base_type, [key_type, value_type])
+        end
+
+        # @param paths [Array<Path>]
+        # @return [self]
+        def change_root(paths)
+          self.class.new(base_type.change_root(paths), type_arguments.map { |type| type.change_root(paths) })
+        end
+
+        # @param base_type      [Types::Base]
+        # @param type_arguments [Array<Base>]
+        def initialize(base_type, type_arguments)
+          @base_type = base_type
+          @type_arguments = type_arguments
+        end
+
+        # @param another [Object]
+        def eql?(another)
+          another.is_a?(GenericType) &&
+          base_type  == another.base_type &&
+          type_arguments == another.type_arguments
+        end
+
+        def hash
+          [self.class.name, base_type, type_arguments].hash
+        end
+
+        # @param namespace [YARD::CodeObjects::Base]
+        # @return [GenericType]
+        def change_root(namespace)
+          self.class.new(base_type.change_root(namespace), type_arguments.map { |type| type.change_root(namespace) })
+        end
+
+        # @param registry [Registry]
+        # @return [Array<YARD::CodeObjects::Base, YARD::CodeObjects::Proxy>]
+        def resolve(registry)
+          base_type.resolve(registry)
+        end
+
+        # @return [String]
+        def to_s
+          "#{base_type}<#{type_arguments.map(&:to_s).join(', ')}>"
+        end
+
+        # @return [self]
+        def map(&block)
+          self.class.new(base_type.map(&block), type_arguments.map(&block))
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/types/instance_type.rb

@@ -0,0 +1,42 @@
+module Yoda
+  module Model
+    module Types
+      class InstanceType < Base
+        # @return [ScopedPath]
+        attr_reader :path
+
+        # @param value [String, Path, ScopedPath]
+        def initialize(path)
+          @path = ScopedPath.build(path)
+        end
+
+        # @param another [Object]
+        def eql?(another)
+          another.is_a?(InstanceType) &&
+          path == another.path
+        end
+
+        def hash
+          [self.class.name, path].hash
+        end
+
+        # @param paths [Array<Path>]
+        # @return [self]
+        def change_root(paths)
+          self.class.new(path.change_scope(paths))
+        end
+
+        # @param registry [Registry]
+        # @return [Array<Store::Objects::Base>]
+        def resolve(registry)
+          [Store::Query::FindConstant.new(registry).find(path)].compact
+        end
+
+        # @return [String]
+        def to_s
+          path.path.to_s
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/types/module_type.rb

@@ -0,0 +1,42 @@
+module Yoda
+  module Model
+    module Types
+      class ModuleType < Base
+        # @return [ScopedPath]
+        attr_reader :path
+
+        # @param value [String, Path, ScopedPath]
+        def initialize(path)
+          @path = ScopedPath.build(path)
+        end
+
+        # @param another [Object]
+        def eql?(another)
+          another.is_a?(ModuleType) &&
+          path == another.path
+        end
+
+        def hash
+          [self.class.name, path].hash
+        end
+
+        # @param paths [Array<Path>]
+        # @return [self]
+        def change_root(paths)
+          self.class.new(path.change_scope(paths))
+        end
+
+        # @param registry [Registry]
+        # @return [Array<YARD::CodeObjects::Base>]
+        def resolve(registry)
+          [Store::Query::FindMetaClass.new(registry).find(path)].compact
+        end
+
+        # @return [String]
+        def to_s
+          "#{path.path.to_s}.module"
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/types/sequence_type.rb

@@ -0,0 +1,53 @@
+module Yoda
+  module Model
+    module Types
+      class SequenceType < Base
+        attr_reader :base_type, :types
+
+        # @param base_type [Base]
+        # @param types [Array<Base>]
+        def initialize(base_type, types)
+          @base_type = base_type
+          @types = types
+        end
+
+        def name
+          base_type.name
+        end
+
+        # @param another [Object]
+        def eql?(another)
+          another.is_a?(SequenceType) &&
+          base_type  == another.base_type &&
+          types == another.types
+        end
+
+        def hash
+          [self.class.name, base_type, types].hash
+        end
+
+        # @param paths [Array<Path>]
+        # @return [self]
+        def change_root(paths)
+          self.class.new(base_type.change_root(paths), types.map { |type| type.change_root(paths) })
+        end
+
+        # @param registry [Registry]
+        # @return [Array<Store::Objects::Base>]
+        def resolve(registry)
+          base_type.resolve(registry)
+        end
+
+        # @return [String]
+        def to_s
+          "#{base_type}(#{types.map(&:to_s).join(', ')})"
+        end
+
+        # @return [self]
+        def map(&block)
+          self.class.new(base_type.map(&block), types.map(&block))
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/types/union_type.rb

@@ -0,0 +1,56 @@
+require 'set'
+
+module Yoda
+  module Model
+    module Types
+      class UnionType < Base
+        attr_reader :types
+
+        # @param types [Array<Base>]
+        # @return [Base]
+        def self.new(types)
+          reduced_types = types.reject { |type| type.is_a?(AnyType) || type.is_a?(UnknownType) }.uniq
+          return (types.first || AnyType.new) if reduced_types.length == 0
+          return reduced_types.first if reduced_types.length == 1
+          super(reduced_types)
+        end
+
+        # @param types [Array<Base>]
+        def initialize(types)
+          @types = types
+        end
+
+        def eql?(another)
+          another.is_a?(UnionType) &&
+          Set.new(types) == Set.new(another.types)
+        end
+
+        def hash
+          [self.class.name, Set.new(types)].hash
+        end
+
+        # @param paths [Array<Path>]
+        # @return [self]
+        def change_root(paths)
+          self.class.new(types.map { |type| type.change_root(paths) })
+        end
+
+        # @param registry [Registry]
+        # @return [Array<Store::Objects::Base>]
+        def resolve(registry)
+          types.map { |type| type.resolve(registry) }.flatten.compact
+        end
+
+        # @return [String]
+        def to_s
+          types.map(&:to_s).join(' | ')
+        end
+
+        # @return [self]
+        def map(&block)
+          self.class.new(types.map(&block))
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/types/unknown_type.rb

@@ -0,0 +1,40 @@
+module Yoda
+  module Model
+    module Types
+      class UnknownType < Base
+        attr_reader :name
+
+        # @param name [String]
+        def initialize(name = 'unknown')
+          @name = name
+        end
+
+        # @param another [Object]
+        def eql?(another)
+          another.is_a?(UnknownType)
+        end
+
+        def hash
+          [self.class.name, name].hash
+        end
+
+        # @param path [Path]
+        # @return [self]
+        def change_root(path)
+          self
+        end
+
+        # @param registry [Registry]
+        # @return [Array<YARD::CodeObjects::Base>]
+        def resolve(registry)
+          []
+        end
+
+        # @return [String]
+        def to_s
+          'any'
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/types/value_type.rb

@@ -0,0 +1,58 @@
+module Yoda
+  module Model
+    module Types
+      class ValueType < Base
+        attr_reader :value
+
+        VALUE_REGEXP = /\A[0-9a-z]/
+
+        # @param value [String]
+        def initialize(value)
+          @value = value
+        end
+
+        # @param another [Object]
+        def eql?(another)
+          another.is_a?(ValueType) &&
+          value == another.value
+        end
+
+        def hash
+          [self.class.name, value].hash
+        end
+
+        # @param paths [Array<Path>]
+        # @return [self]
+        def change_root(paths)
+          self
+        end
+
+        # @param registry [Registry]
+        # @return [Array<YARD::CodeObjects::Base>]
+        def resolve(registry)
+          [Store::Query::FindConstant.new(registry).find(value_class)].compact
+        end
+
+        def value_class
+          case value
+          when 'true'
+            '::TrueClass'
+          when 'false'
+            '::FalseClass'
+          when 'nil'
+            '::NilClass'
+          when /\A\d+\Z/
+            '::Numeric'
+          else
+            nil
+          end
+        end
+
+        # @return [String]
+        def to_s
+          value
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/values.rb

@@ -0,0 +1,9 @@
+module Yoda
+  module Model
+    module Values
+      require 'yoda/model/values/base'
+      require 'yoda/model/values/instance_value'
+      require 'yoda/model/values/module_value'
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Yoda
+  module Model
+    module Values
+      # @abstract
+      class Base
+        # @abstract
+        # @return [Array<Functions::Base>]
+        def methods
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [String]
+        def path
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [String]
+        def docstring
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Array<[String, Integer]>]
+        def defined_files
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Yoda
+  module Model
+    module Values
+      class InstanceValue < Base
+        # @type Registry
+        attr_reader :registry
+
+        # @type ::YARD::CodeObjects::ClassObject | ::YARD::CodeObjects::Proxy
+        attr_reader :class_object
+
+        # @param registry [Registry]
+        # @param class_object [::YARD::CodeObjects::ClassObject, ::YARD::CodeObjects::Proxy]
+        def initialize(registry, class_object)
+          fail ArgumentError, registry unless registry.is_a?(Registry)
+          fail ArgumentError, class_object unless class_object.is_a?(::YARD::CodeObjects::NamespaceObject) || class_object.is_a?(::YARD::CodeObjects::Proxy)
+          @registry = registry
+          @class_object = class_object
+        end
+
+        # @return [Array<Functions::Base>]
+        def methods(visibility: nil)
+          return [] if class_object.type == :proxy
+          opts = { scope: :instance, visibility: visibility }.compact
+          class_object.meths(opts).map { |meth| Functions::Method.new(meth) } + object_methods(visibility: visibility)
+        end
+
+        # @return [String]
+        def path
+          namespace.path
+        end
+
+        def namespace
+          class_object
+        end
+
+        # @param [String]
+        def docstring
+          class_object.docstring
+        end
+
+        # @return [Array<[String, Integer]>]
+        def defined_files
+          namespace.files
+        end
+
+        private
+
+        # @return [Array<Functions::Base>]
+        def object_methods(visibility: nil)
+          return [] if class_object.type == :proxy
+          opts = { scope: :instance, visibility: visibility }.compact
+          method_names = Set.new(class_object.meths(opts).map(&:name))
+          if object = registry.find('::Object')
+            object.meths(opts)
+              .reject { |o| ![visibility].flatten.include?(:private) && o.namespace.name == :Kernel }
+              .reject { |o| method_names.include?(o.name) }
+              .map { |meth| Functions::Method.new(meth) }
+          else
+            []
+          end
+        end
+      end
+    end
+  end
+end