yoda-language-server 0.4.0

data/lib/yoda/model/path.rb

@@ -0,0 +1,96 @@
+module Yoda
+  module Model
+    class Path
+      attr_reader :name
+
+      # @param path [Path, String]
+      # @return [Path]
+      def self.build(path)
+        path.is_a?(Path) ? path : new(path)
+      end
+
+      # @param names [Array<Path, String>]
+      # @return [Path]
+      def self.from_names(names)
+        new(names.join('::'))
+      end
+
+      # @param name [String]
+      def initialize(name)
+        fail ArgumentError, name unless name.is_a?(String)
+        @name = name
+      end
+
+      def absolute?
+        name.start_with?('::')
+      end
+
+      # @return [String]
+      def basename
+        @basename ||= begin
+          if name.end_with?('::')
+            ''
+          else
+            name.split('::').last || ''
+          end
+        end
+      end
+
+      # @return [String]
+      def spacename
+        @spacename ||= begin
+          if name.end_with?('::')
+            name.gsub(/::\Z/, '')
+          else
+            name.split('::').slice(0..-2).join('::')
+          end
+        end
+      end
+
+      # @return [String]
+      def to_s
+        name
+      end
+
+      def split
+        name.gsub(/\A::/, '').split('::') + (name.end_with?('::') ? [''] : [])
+      end
+
+      # @param another [Path, String]
+      # @return [Path]
+      def concat(another)
+        if self.class.build(another).absolute?
+          self
+        else
+          self.class.new([self.to_s, another.to_s].reject(&:empty?).join('::'))
+        end
+      end
+
+      # @return [Array<String>]
+      def namespaces
+        name.split('::')
+      end
+
+      # @return [Array<Path>]
+      def parent_paths
+        if spacename.empty?
+          []
+        else
+          [spacename] + Path.new(spacename).parent_paths
+        end
+      end
+
+      def hash
+        [self.class.name, name].hash
+      end
+
+      def ==(another)
+        eql?(another)
+      end
+
+      def eql?(another)
+        another.is_a?(Path) && name == another.name
+      end
+    end
+  end
+end

data/lib/yoda/model/scoped_path.rb

@@ -0,0 +1,44 @@
+module Yoda
+  module Model
+    # ScopedPath represents a path name written in namespaces.
+    # ScopedPath owns lexical scopes where the path is written.
+    class ScopedPath
+      # @return [Array<Path>] represents namespaces in order of nearness.
+      attr_reader :scopes
+
+      # @return [Path]
+      attr_reader :path
+
+      # @param path [Path]
+      # @return [ScopedPath]
+      def self.build(path)
+        path.is_a?(ScopedPath) ? path : ScopedPath.new(['Object'], Path.build(path))
+      end
+
+      # @param scopes [Array<Path>] represents namespaces in order of nearness.
+      # @param path [Path]
+      def initialize(scopes, path)
+        @scopes = scopes.map { |pa| Path.build(pa) }
+        @path = Path.build(path)
+      end
+
+      # @param paths [Array<String, Path>]
+      # @return [ScopedPath]
+      def change_scope(paths)
+        self.class.new(paths, path)
+      end
+
+      def hash
+        [self.class.name, scopes, path].hash
+      end
+
+      def ==(another)
+        eql?(another)
+      end
+
+      def eql?(another)
+        another.is_a?(ScopedPath) && path == another.path && scopes == another.scopes
+      end
+    end
+  end
+end

data/lib/yoda/model/types.rb

@@ -0,0 +1,84 @@
+require 'parslet'
+
+module Yoda
+  module Model
+    module Types
+      require 'yoda/model/types/base'
+      require 'yoda/model/types/any_type'
+      require 'yoda/model/types/value_type'
+      require 'yoda/model/types/instance_type'
+      require 'yoda/model/types/function_type'
+      require 'yoda/model/types/duck_type'
+      require 'yoda/model/types/module_type'
+      require 'yoda/model/types/sequence_type'
+      require 'yoda/model/types/generic_type'
+      require 'yoda/model/types/union_type'
+      require 'yoda/model/types/unknown_type'
+
+      # @param string [String]
+      # @return [Types::Base]
+      def self.parse(string)
+        Parsing::Generator.new.apply(Parsing::Parser.new.parse(string))
+      rescue Parslet::ParseFailed => failure
+        Types::UnknownType.new(string)
+      end
+
+      # @param strings [Array<String>]
+      # @return [Types::Base]
+      def self.parse_type_strings(strings)
+        Types::UnionType.new(strings.map { |string| parse(string) })
+      end
+
+      module Parsing
+        class Parser < Parslet::Parser
+          rule(:method_name) { match('[a-z]') >> match('[a-zA-Z0-9_]').repeat }
+          rule(:duck_type) { str('#') >> method_name.as(:method_name) }
+          rule(:constant_name) { match('[A-Z]') >> match('[a-zA-Z0-9_]').repeat }
+          rule(:constant_full_name) { str('::').maybe >> (constant_name >> (str('::') | str('.'))).repeat >> constant_name }
+          rule(:value_name) { match('[a-z0-9]') >> match('[a-zA-Z0-9_]').repeat }
+
+          rule(:space) { match('\s').repeat(1) }
+          rule(:space?) { space.maybe }
+
+          rule(:constant_type) { value_name.as(:value) | constant_full_name.as(:instance_type) }
+
+          rule(:key_value_type) { constant_type.as(:base_type) >> str('{') >> space? >> type.as(:key_type) >> space? >> str('=>') >> space? >> type.as(:value_type) >> space? >> str('}') }
+          rule(:sequence_type) { constant_type.as(:base_type) >> str('(') >> space? >> types.as(:value_types) >> space? >> str(')') }
+          rule(:generic_type) { constant_type.as(:base_type) >> (str('<') >> space? >> type >> space? >> str('>')).repeat(1).as(:type_arguments) }
+
+          rule(:shorthand_key_value) { str('{') >> space? >> type.as(:key_type) >> space? >> str('=>') >> space? >> type.as(:value_type) >> space? >> str('}') }
+          rule(:shorthand_sequence) { str('(') >> space? >> types.as(:value_types) >> space? >> str(')') }
+          rule(:shorthand_array) { str('<') >> space? >> type.as(:type_in_array) >> space? >> str('>') }
+
+          rule(:union_type) { types.as(:types) }
+
+          rule(:single_type) { duck_type | shorthand_key_value | shorthand_array | shorthand_sequence | generic_type | key_value_type | sequence_type | constant_type }
+          rule(:types) { (single_type >> str(',') >> space?).repeat >> space? >> single_type }
+
+          rule(:type) { union_type }
+          rule(:base) { space? >> type >> space? }
+          root :base
+        end
+
+        class Generator < Parslet::Transform
+          rule(instance_type: simple(:instance_type)) { Types::InstanceType.new(instance_type.to_s) }
+          rule(value: simple(:value)) { Types::ValueType.new(value.to_s) }
+
+          rule(base_type: simple(:base_type), key_type: simple(:key_type), value_type: simple(:value_type)) { Types::GenericType.from_key_value(base_type, key_type, value_type) }
+          rule(base_type: simple(:base_type), value_types: sequence(:value_types)) { Types::SequenceType.new(base_type, value_types) }
+          rule(base_type: simple(:base_type), value_types: simple(:value_type)) { Types::SequenceType.new(base_type, [value_type]) }
+          rule(base_type: simple(:base_type), type_arguments: sequence(:type_arguments)) { Types::GenericType.new(base_type, type_arguments) }
+
+          rule(method_name: simple(:method_name)) { Types::DuckType.new(method_name) }
+          rule(key_type: simple(:key_type), value_type: simple(:value_type)) { Types::GenericType.from_key_value(Types::InstanceType.new('::Hash'), key_type, value_type) }
+          rule(value_types: sequence(:value_types)) { Types::SequenceType.new(Types::InstanceType.new('::Array'), value_types) }
+          rule(value_types: simple(:value_type)) { Types::SequenceType.new(Types::InstanceType.new('::Array'), [value_type]) }
+          rule(type_in_array: simple(:type)) { Types::GenericType.new(Types::InstanceType.new('::Array'), [type]) }
+
+          rule(types: sequence(:types)) { Types::UnionType.new(types) }
+          rule(types: simple(:type)) { type }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Yoda
+  module Model
+    module Types
+      class AnyType < Base
+        def eql?(another)
+          another.is_a?(AnyType)
+        end
+
+        def hash
+          [self.class.name].hash
+        end
+
+        # @param paths [Array<Paths>]
+        # @return [self]
+        def change_root(paths)
+          self
+        end
+
+        # @param registry [Registry]
+        # @return [Array<Store::Objects::Base>]
+        def resolve(registry)
+          []
+        end
+
+        # @return [String]
+        def to_s
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Yoda
+  module Model
+    module Types
+      # @abstract
+      class Base
+        def ==(another)
+          eql?(another)
+        end
+
+        # @abstract
+        # @param paths [Array<Path>]
+        # @return [Base]
+        def change_root(paths)
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @param registry [Registry]
+        # @return [Array<Store::Objects::Base>]
+        def resolve(registry)
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [String]
+        def to_s
+          fail NotImplementedError
+        end
+
+        # @return [Base]
+        def map
+          yield self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Yoda
+  module Model
+    module Types
+      class DuckType < Base
+        attr_reader :method_name
+
+        # @param method_name [String]
+        def initialize(method_name)
+          @method_name = method_name
+        end
+
+        # @param another [Object]
+        def eql?(another)
+          another.is_a?(DuckType) &&
+          method_name == another.method_name
+        end
+
+        def hash
+          [self.class.name, method_name].hash
+        end
+
+        # @param paths [Array<Paths>]
+        # @return [self]
+        def change_root(paths)
+          self
+        end
+
+        # @param registry [Registry]
+        # @return [Array<Store::Objects::Base>]
+        def resolve(registry)
+          []
+        end
+
+        # @return [String]
+        def to_s
+          "##{method_name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+module Yoda
+  module Model
+    module Types
+      class FunctionType < Base
+        # @return [Base, nil]
+        attr_reader :context
+
+        # @return [Array<Base>]
+        attr_reader :required_parameters, :optional_parameters, :post_parameters
+
+        # @return [Array<(String, Base)>]
+        attr_reader :required_keyword_parameters
+
+        # @return [Array<(String, Base)>]
+        attr_reader :optional_keyword_parameters
+
+        # @return [Base, nil]
+        attr_reader :rest_parameter, :keyword_rest_parameter, :block_parameter
+
+        # @return [Base]
+        attr_reader :return_type
+
+        # @param context [Base, nil]
+        # @param required_parameters [Array<Base>]
+        # @param optional_parameters [Array<Base>]
+        # @param rest_parameter [Base, nil]
+        # @param post_parameters [Array<Base>]
+        # @param keyword_parameters [Array<(String, Base)>]
+        # @param keyword_rest_parameter [Base, nil]
+        # @param block_parameter [Base, nil]
+        # @param return_type [Base]
+        def initialize(context: nil, return_type:, required_parameters: [], optional_parameters: [], rest_parameter: nil, post_parameters: [], optional_keyword_parameters: [], required_keyword_parameters: [], keyword_rest_parameter: nil, block_parameter: nil)
+          @context = context
+          @required_parameters = required_parameters
+          @optional_parameters = optional_parameters
+          @required_keyword_parameters = required_keyword_parameters
+          @optional_keyword_parameters = optional_keyword_parameters
+          @rest_parameter = rest_parameter
+          @post_parameters = post_parameters
+          @keyword_rest_parameter = keyword_rest_parameter
+          @block_parameter = block_parameter
+          @return_type = return_type
+        end
+
+        def eql?(another)
+          another.is_a?(FunctionType) &&
+          context == another.context &&
+          required_parameters == another.required_parameters &&
+          optional_parameters == another.optional_parameters &&
+          required_keyword_parameters.to_set == another.required_keyword_parameters.to_set &&
+          optional_keyword_parameters.to_set == another.optional_keyword_parameters.to_set &&
+          keyword_rest_parameter == another.keyword_rest_parameter &&
+          rest_parameter == another.rest_parameter &&
+          post_parameters == another.post_parameters &&
+          block_parameter == another.block_parameter &&
+          return_type == another.return_type
+        end
+
+        def hash
+          [
+            self.class.name,
+            context,
+            return_type,
+            required_parameters,
+            optional_parameters,
+            rest_parameter,
+            post_parameters,
+            required_keyword_parameters,
+            optional_keyword_parameters,
+            keyword_rest_parameter,
+            block_parameter,
+          ].hash
+        end
+
+        # @param namespace [YARD::CodeObjects::Base]
+        # @return [UnionType]
+        def change_root(namespace)
+          self.class.new(
+            context: context&.change_root(namespace),
+            return_type: return_type.change_root(namespace),
+            required_parameters: required_parameters.map { |param| param.change_root(namespace) },
+            optional_parameters: optional_parameters.map { |param| param.change_root(namespace) },
+            rest_parameter: rest_parameter&.change_root(namespace),
+            post_parameters: post_parameters.map { |param| param.change_root(namespace) },
+            required_keyword_parameters: required_keyword_parameters.map { |name, param| [name, param.change_root(namespace)] },
+            optional_keyword_parameters: required_keyword_parameters.map { |name, param| [name, param.change_root(namespace)] },
+            keyword_rest_parameter: keyword_rest_parameter&.change_root(namespace),
+            block_parameter: block_parameter&.change_root(namespace),
+          )
+        end
+
+        # @param registry [Registry]
+        # @return [Array<Store::Objects::Base>]
+        def resolve(registry)
+          []
+        end
+
+        def method_type_signature
+          params_str = all_parameters_to_s
+          (params_str.empty? ? ': ' : "(#{params_str}): ") + "#{return_type}"
+        end
+
+        def to_s
+          params_str = all_parameters_to_s
+          (params_str.empty? ? '' : "(#{params_str}) -> ") + "#{return_type}"
+        end
+
+        # @return [self]
+        def map(&block)
+          self.class.new(
+            context: context&.map(&block),
+            return_type: return_type.map(&block),
+            required_parameters: required_parameters.map { |param| param.map(&block) },
+            optional_parameters: optional_parameters.map { |param| param.map(&block) },
+            rest_parameter: rest_parameter&.map(&block),
+            post_parameters: post_parameters.map { |param| param.map(&block) },
+            required_keyword_parameters: required_keyword_parameters.map { |name, param| [name, param.map(&block)] },
+            optional_keyword_parameters: required_keyword_parameters.map { |name, param| [name, param.map(&block)] },
+            keyword_rest_parameter: keyword_rest_parameter&.map(&block),
+            block_parameter: block_parameter&.map(&block),
+          )
+        end
+
+        private
+
+        def all_parameters_to_s
+          [
+            required_parameters_to_s,
+            optional_parameters_to_s,
+            rest_parameter_to_s,
+            post_parameters_to_s,
+            keyword_parameters_to_s,
+            keyword_rest_parameter_to_s,
+            block_parameter_to_s
+          ].reject { |str| str.empty? }.join(', ')
+        end
+
+        def required_parameters_to_s
+          required_parameters.map { |type| type.to_s }.join(', ')
+        end
+
+        def optional_parameters_to_s
+          optional_parameters.map { |type| "?#{type}" }.join(', ')
+        end
+
+        def required_keyword_parameters_to_s
+          return '' if required_keyword_parameters.empty?
+          required_keyword_parameters.map { |(name, type)| "#{name}: #{type}" }.join(', ')
+        end
+
+        def optional_keyword_parameters_to_s
+          return '' if optional_keyword_parameters.empty?
+          optional_keyword_parameters.map { |(name, type)| "?#{name}: #{type}" }.join(', ')
+        end
+
+        def post_parameters_to_s
+          post_parameters.map { |type| type.to_s }.join(', ')
+        end
+
+        def rest_parameter_to_s
+          rest_parameter ? "*#{rest_parameter}" : ''
+        end
+
+        def keyword_rest_parameter_to_s
+          keyword_rest_parameter ? "**#{keyword_rest_parameter}" : ''
+        end
+
+        def block_parameter_to_s
+          block_parameter ? "&#{block_parameter}" : ''
+        end
+      end
+    end
+  end
+end