yoda-language-server 0.4.0

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

@@ -0,0 +1,41 @@
+module Yoda
+  module Store
+    module Objects
+      class MetaClassObject < NamespaceObject
+        # @param path [String]
+        # @return [String]
+        def self.address_of(path)
+          "#{path}%class"
+        end
+
+        # @param path [String]
+        # @param document [Document, nil]
+        # @param tag_list [TagList, nil]
+        # @param instance_method_paths [Array<String>]
+        # @param instance_mixin_paths [Array<String>]
+        def initialize(**kwargs)
+          super(kwargs)
+        end
+
+        # @return [String]
+        def name
+          @name ||= path.match(MODULE_TAIL_PATTERN) { |md| md[1] || md[2] }
+        end
+
+        def kind
+          :meta_class
+        end
+
+        # @return [String]
+        def address
+          MetaClassObject.address_of(path)
+        end
+
+        # @return [String]
+        def base_class_address
+          path
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module Yoda
+  module Store
+    module Objects
+      class MethodObject < Base
+        # @return [Array<(String, String)>]
+        attr_reader :parameters
+
+        # @return [Symbol]
+        attr_reader :visibility
+
+        # @return [Array<Overload>]
+        attr_reader :overloads
+
+        class << self
+          # @param path [String]
+          # @return [String]
+          def namespace_of_path(path)
+            path.slice(0, (path.rindex(/[#.]/) || 0))
+          end
+
+          # @param path [String]
+          # @return [String]
+          def name_of_path(path)
+            path.slice((path.rindex(/[#.]/) || -1) + 1, path.length)
+          end
+
+          # @param path [String]
+          # @return [String]
+          def sep_of_path(path)
+            path.slice(path.rindex(/[#.]/))
+          end
+
+          # @return [Array<Symbol>]
+          def attr_names
+            super + %i(parameters visibility overloads)
+          end
+        end
+
+        # @param path [String]
+        # @param document [Document, nil]
+        # @param tag_list [TagList, nil]
+        # @param visibility [Symbol]
+        # @param overloads [Array<Overload>]
+        # @param parameters [Array<(String, String)>, nil]
+        def initialize(parameters: [], visibility: :public, overloads: [], **kwargs)
+          super(kwargs)
+          fail ArgumentError, visibility unless %i(public private protected)
+          @visibility = visibility.to_sym
+          @parameters = parameters
+          @overloads = overloads
+        end
+
+        # @return [String]
+        def name
+          @name ||= MethodObject.name_of_path(path)
+        end
+
+        # @return [String]
+        def sep
+          @sep ||= MethodObject.sep_of_path(path)
+        end
+
+        # @return [String]
+        def namespace_path
+          @namespace_path ||= MethodObject.namespace_of_path(path)
+        end
+
+        def kind
+          :method
+        end
+
+        def to_h
+          super.merge(
+            parameters: parameters.to_a,
+            visibility: visibility,
+            overloads: overloads,
+          )
+        end
+
+        private
+
+        # @param another [self]
+        # @return [Hash]
+        def merge_attributes(another)
+          super.merge(
+            visibility: another.visibility,
+            parameters: another.parameters.to_a,
+            overloads: overloads + another.overloads,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Yoda
+  module Store
+    module Objects
+      class ModuleObject < NamespaceObject
+        def kind
+          :module
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module Yoda
+  module Store
+    module Objects
+      # @abstract
+      class NamespaceObject < Base
+        # @return [Array<String>]
+        attr_reader :instance_method_addresses
+
+        # @type Array<String>
+        attr_reader :mixin_addresses
+
+        # @type Array<String>
+        attr_reader :constant_addresses
+
+        # @return [Enumerable<NamespaceObject>]
+        attr_accessor :ancestors
+
+        # @return [Enumerable<MethodObject>]
+        attr_accessor :methods
+
+        # @return [Array<Symbol>]
+        def self.attr_names
+          super + %i(instance_method_addresses mixin_addresses constant_addresses)
+        end
+
+        # @param path [String]
+        # @param document [Document, nil]
+        # @param tag_list [TagList, nil]
+        # @param instance_method_paths [Array<String>]
+        # @param constant_addresses [Array<String>]
+        # @param mixin_addresses [Array<String>]
+        def initialize(instance_method_addresses: [], mixin_addresses: [], constant_addresses: [], **kwargs)
+          super(kwargs)
+          @instance_method_addresses = instance_method_addresses
+          @mixin_addresses = mixin_addresses
+          @constant_addresses = constant_addresses
+          @ancestors ||= []
+        end
+
+        # @return [String]
+        def name
+          @name ||= path.match(MODULE_TAIL_PATTERN) { |md| md[1] || md[2] }
+        end
+
+        def to_h
+          super.merge(
+            instance_method_addresses: instance_method_addresses,
+            mixin_addresses: mixin_addresses,
+            constant_addresses: constant_addresses,
+          )
+        end
+
+        private
+
+        # @param another [self]
+        # @return [Hash]
+        def merge_attributes(another)
+          super.merge(
+            instance_method_addresses: (instance_method_addresses + another.instance_method_addresses).uniq,
+            mixin_addresses: (mixin_addresses + another.mixin_addresses).uniq,
+            constant_addresses: (constant_addresses + another.constant_addresses).uniq,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Yoda
+  module Store
+    module Objects
+      class Overload
+        class << self
+          def json_creatable?
+            true
+          end
+
+          # @param params [Hash]
+          def json_create(params)
+            new(params.map { |k, v| [k.to_sym, v] }.select { |(k, v)| %i(name tag_list document parameters).include?(k) }.to_h)
+          end
+        end
+
+        # @return [String]
+        attr_reader :name
+
+        # @return [Array<(String, String)>]
+        attr_reader :parameters
+
+        # @return [String, nil]
+        attr_reader :document
+
+        # @return [Array<Tag>]
+        attr_reader :tag_list
+
+        # @param name [String]
+        # @param parameters [Array<(String, String)>]
+        # @param document [String]
+        # @param tag_list [Array<Tag>]
+        def initialize(name:, parameters: [], document: '', tag_list: [])
+          @name = name
+          @parameters = parameters
+          @document = document
+          @tag_list = tag_list
+        end
+
+        # @return [Hash]
+        def to_h
+          { name: name, parameters: parameters, document: document, tag_list: tag_list }
+        end
+
+        # @return [String]
+        def to_json(_mode = nil)
+          to_h.merge(json_class: self.class.name).to_json
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Yoda
+  module Store
+    module Objects
+      class Patch
+        # @param id [String]
+        attr_reader :id
+
+        # @param registry [Hash{ Symbol => Addressable }]
+        attr_reader :registry
+
+        # @param id [String]
+        def initialize(id)
+          @id = id
+          @registry = Hash.new
+        end
+
+        # @param addressable [Addressable]
+        # @return [void]
+        def register(addressable)
+          if el = @registry[addressable.address.to_sym]
+            @registry[addressable.address.to_sym] = el.merge(addressable)
+          else
+            @registry[addressable.address.to_sym] = addressable
+          end
+        end
+
+        # @param address [String, Symbol]
+        # @return [Addressable, nil]
+        def find(address)
+          @registry[address.to_sym]
+        end
+
+        # @param address [String, Symbol]
+        # @return [true, false]
+        def has_key?(address)
+          @registry.has_key?(address.to_sym)
+        end
+
+        # @return [Array<Symbol>]
+        def keys
+          @registry.keys
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+module Yoda
+  module Store
+    module Objects
+      # PatchSet manages patch updates and patch outdates.
+      # Besides, this class provides api to modify objects by using owning patches.
+      class PatchSet
+        # @return [{ Symbol => Array<Symbol> }]
+        attr_reader :address_index
+
+        # @return [{ Symbol => Patch }]
+        attr_reader :patches
+
+        def initialize
+          @patches = Hash.new
+          @address_index = Hash.new
+        end
+
+        # @param patch [Patch]
+        # @return [void]
+        def register(patch)
+          register_to_index(patch)
+          patches[patch.id.to_sym] = patch
+        end
+
+        # @param id [String, Symbol]
+        def delete(id)
+          patches.delete(id.to_sym)
+        end
+
+        # @param object [Addressable]
+        # @return [Addressable]
+        def patch(object)
+          check_outdated_index(object.address.to_sym)
+          objects_in_patch = (address_index[object.address.to_sym] || []).map { |patch_id| patches[patch_id].find(object.address.to_sym) }
+          Merger.new([object, *objects_in_patch]).merged_instance
+        end
+
+        # @param address [String, Symbol]
+        # @return [Addressable, nil]
+        def find(address)
+          check_outdated_index(address.to_sym)
+          if (patch_ids = address_index[address.to_sym] || []).empty?
+            nil
+          else
+            objects = patch_ids.map { |id| patches[id].find(address.to_sym) }
+            Merger.new(objects).merged_instance
+          end
+        end
+
+        # @return [Array<Symbol>]
+        def keys
+          address_index.keys
+        end
+
+        # @param address [String, Symbol]
+        # @return [true, false]
+        def has_key?(address)
+          check_outdated_index(address.to_sym)
+          address_index[address.to_sym] && !address_index[address.to_sym].empty?
+        end
+
+        private
+
+        # @param patch [Patch]
+        # @return [void]
+        def register_to_index(patch)
+          patch.keys.each do |key|
+            address_index[key.to_sym] ||= []
+            address_index[key.to_sym].push(patch.id.to_sym)
+          end
+        end
+
+        # @param address [Symbol]
+        def check_outdated_index(address)
+          (address_index[address] || []).select! { |patch_id| patches[patch_id].has_key?(address) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Yoda
+  module Store
+    module Objects
+      class Tag
+        class << self
+          def json_creatable?
+            true
+          end
+
+          # @param params [Hash]
+          def json_create(params)
+            new(params.map { |k, v| [k.to_sym, v] }.select { |(k, v)| %i(tag_name name yard_types text lexical_scope).include?(k) }.to_h)
+          end
+        end
+
+        # @return [String]
+        attr_reader :tag_name
+
+        # @return [String, nil]
+        attr_reader :name, :text
+
+        # @return [Array<String>]
+        attr_reader :yard_types, :lexical_scope
+
+        # @param tag_name   [String]
+        # @param name       [String, nil]
+        # @param yard_types [Array<String>]
+        # @param text       [String, nil]
+        # @param lexical_scope [Array<String>]
+        def initialize(tag_name:, name: nil, yard_types: [], text: nil, lexical_scope: [])
+          @tag_name = tag_name
+          @name = name
+          @yard_types = yard_types
+          @text = text
+          @lexical_scope = lexical_scope
+        end
+
+        # @return [Hash]
+        def to_h
+          { name: name, tag_name: tag_name, yard_types: yard_types, text: text, lexical_scope: lexical_scope }
+        end
+
+        def hash
+          ([self.class.name] + to_h.to_a).hash
+        end
+
+        def eql?(another)
+          self.class == another.class && to_h == another.to_h
+        end
+
+        def ==(another)
+          eql?(another)
+        end
+
+        # @return [String]
+        def to_json(_state = nil)
+          to_h.merge(json_class: self.class.name).to_json
+        end
+      end
+    end
+  end
+end