rucoa 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 237fa68185426d66437c43fc2a3f34f7f85ee7309eb4ed6bb6ce4e31b5dfbb6e
-  data.tar.gz: e9f96daf65c7ccef564b2e06756497fd4d98bd946911487ca2fdd32740436e4b
+  metadata.gz: cec8d0284ecf97b03cd43de02d36c16263910dba3c5a1052f73df0bf0fd51f68
+  data.tar.gz: b83c8aad102fbd510a0f7474394ab8cf91cd17976bbc365e188c276789815e9a
 SHA512:
-  metadata.gz: 3698e9db246d46ce64314df9b4a7418278a6e9f65cc2e80dfece624b547c5ab238af42b456370d1096e872f6e30aefdb132b5b2bd435ec03d1e6cccdac0a908a
-  data.tar.gz: 5088d4dcc1fa5ad6e053a155246da87602071fa8283b4f42e1b4e9040b222be5f82622343ad2467b5cdf8003b02293e70ea8d391dc99f478ee36a1389311a9d4
+  metadata.gz: 3042168fc7a78f71854f96d8367f9f4e1e0c62d4300b4feef36b6596e602b3c40c5150d1d6f0902ab5d7b1015179cdf10c2d1e6beabe68cbf3fa1114f6cdb00e
+  data.tar.gz: 6721bdccd41cb883d6b6ab97a5a990b878e088a7832ccb6c42bcc642ff13f1ab3126d8893a43b47a29295caa0ff14ed4b59bdf5ab0ca95c14a4536dee11eb899

data/.rubocop.yml

@@ -32,9 +32,18 @@ RSpec/NamedSubject:
 Security/MarshalLoad:
   Enabled: false
 
+Sevencop/AutoloadOrdered:
+  Enabled: true
+
 Sevencop/HashLiteralOrder:
   Enabled: true
 
+Sevencop/MethodDefinitionKeywordArgumentsOrdered:
+  Enabled: true
+
+Sevencop/MethodDefinitionMultilineArguments:
+  Enabled: true
+
 Style/Documentation:
   Enabled: false
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rucoa (0.9.0)
+    rucoa (0.11.0)
       parser
       rbs
       rubocop
@@ -27,13 +27,13 @@ GEM
       rspec-mocks (~> 3.11.0)
     rspec-core (3.11.0)
       rspec-support (~> 3.11.0)
-    rspec-expectations (3.11.0)
+    rspec-expectations (3.11.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.11.0)
     rspec-mocks (3.11.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.11.0)
-    rspec-support (3.11.0)
+    rspec-support (3.11.1)
     rubocop (1.36.0)
       json (~> 2.3)
       parallel (~> 1.10)
@@ -46,17 +46,17 @@ GEM
       unicode-display_width (>= 1.4.0, < 3.0)
     rubocop-ast (1.21.0)
       parser (>= 3.1.1.0)
-    rubocop-performance (1.14.3)
+    rubocop-performance (1.15.0)
       rubocop (>= 1.7.0, < 2.0)
       rubocop-ast (>= 0.4.0)
     rubocop-rake (0.6.0)
       rubocop (~> 1.0)
-    rubocop-rspec (2.12.1)
-      rubocop (~> 1.31)
+    rubocop-rspec (2.13.2)
+      rubocop (~> 1.33)
     ruby-progressbar (1.11.0)
-    sevencop (0.10.0)
+    sevencop (0.13.0)
       rubocop
-    unicode-display_width (2.2.0)
+    unicode-display_width (2.3.0)
     webrick (1.7.0)
     yard (0.9.28)
       webrick (~> 1.7.0)

data/lib/rucoa/configuration.rb

@@ -148,7 +148,10 @@ module Rucoa
     # @param keys [Array<String>]
     # @param default [Object]
     # @return [Object]
-    def fetch(*keys, default:)
+    def fetch(
+      *keys,
+      default:
+    )
       value = @settings.dig(*keys)
       if value.nil?
         default

data/lib/rucoa/definition_store.rb

@@ -3,22 +3,29 @@
 module Rucoa
   class DefinitionStore
     def initialize
-      @definition_by_full_qualified_name = {}
-      @fully_qualified_names_by_uri = ::Hash.new { |hash, key| hash[key] = [] }
+      @definition_by_qualified_name = {}
+      @qualified_names_by_uri = ::Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    # @return [String]
+    def inspect
+      "#<#{self.class} definitions_count=#{@definition_by_qualified_name.count}>"
     end
 
     # @param definitions [Array<Rucoa::Definition::Base>]
     # @return [void]
     def bulk_add(definitions)
-      definitions.each do |definition|
-        @fully_qualified_names_by_uri["file://#{definition.source_path}"] << definition.fully_qualified_name
-        @definition_by_full_qualified_name[definition.fully_qualified_name] = definition
+      definitions.group_by(&:qualified_name).each_value.map do |grouped_definitions|
+        grouped_definitions.reduce(:merge!)
+      end.each do |definition|
+        @qualified_names_by_uri[definition.location.uri] << definition.qualified_name if definition.location
+        @definition_by_qualified_name[definition.qualified_name] = definition
       end
     end
 
     # @param source [Rucoa::Source]
     # @return [void]
-    # @example resolves super class name correctly by using existent definitions
+    # @example resolves super class name from definitions
     #   definition_store = Rucoa::DefinitionStore.new
     #   foo = Rucoa::Source.new(
     #     content: <<~RUBY,
@@ -40,115 +47,297 @@ module Rucoa
     #     uri: 'file:///path/to/a/bar.rb',
     #   )
     #   definition_store.update_from(bar)
-    #   definition = definition_store.find_definition_by_fully_qualified_name('A::Bar')
-    #   expect(definition.super_class_fully_qualified_name).to eq('A::Foo')
+    #   definition = definition_store.find_definition_by_qualified_name('A::Bar')
+    #   expect(definition.super_class_qualified_name).to eq('A::Foo')
+    # @example resolves included module names from definitions
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   foo = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         module Foo
+    #         end
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/a/foo.rb',
+    #   )
+    #   definition_store.update_from(foo)
+    #   bar = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         class Bar
+    #           include Foo
+    #         end
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/a/bar.rb',
+    #   )
+    #   definition_store.update_from(bar)
+    #   definition = definition_store.find_definition_by_qualified_name('A::Bar')
+    #   expect(definition.included_module_qualified_names).to eq(%w[A::Foo])
     def update_from(source)
-      delete_definitions_about(source)
-
-      # Need to store definitions before super class resolution.
-      source.definitions.group_by(&:source_path).each do |source_path, definitions|
-        @fully_qualified_names_by_uri["file://#{source_path}"] += definitions.map(&:fully_qualified_name)
-        definitions.each do |definition|
-          @definition_by_full_qualified_name[definition.fully_qualified_name] = definition
-        end
-      end
-
-      source.definitions.each do |definition|
-        next unless definition.is_a?(Definitions::ClassDefinition)
-        next if definition.super_class_resolved?
-
-        definition.super_class_fully_qualified_name = resolve_super_class_of(definition)
-      end
+      delete_definitions_in(source)
+      add_definitions_in(source)
+      resolve_constants_in(source)
     end
 
-    # @param fully_qualified_name [String]
+    # @param qualified_name [String]
     # @return [Rucoa::Definitions::Base, nil]
-    def find_definition_by_fully_qualified_name(fully_qualified_name)
-      @definition_by_full_qualified_name[fully_qualified_name]
+    def find_definition_by_qualified_name(qualified_name)
+      @definition_by_qualified_name[qualified_name]
     end
 
     # @param method_name [String]
     # @param namespace [String]
     # @param singleton [Boolean]
     # @return [Rucoa::Definition::MethodDefinition, nil]
-    # @example has the ability to find `IO.write` from `File.write`
+    # @example Supports inheritance
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       class A
+    #         def foo
+    #         end
+    #       end
+    #
+    #       class B < A
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
     #   definition_store = Rucoa::DefinitionStore.new
-    #   definition_store.bulk_add(Rucoa::DefinitionArchiver.load)
+    #   definition_store.update_from(source)
     #   subject = definition_store.find_method_definition_by(
-    #     method_name: 'write',
-    #     namespace: 'File',
-    #     singleton: true
+    #     method_name: 'foo',
+    #     namespace: 'B',
+    #     singleton: false
     #   )
-    #   expect(subject.fully_qualified_name).to eq('IO.write')
-    def find_method_definition_by(method_name:, namespace:, singleton: false)
-      definition = find_definition_by_fully_qualified_name(namespace)
+    #   expect(subject.qualified_name).to eq('A#foo')
+    # @example supports `include`
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         def foo
+    #         end
+    #       end
+    #
+    #       class B
+    #         include A
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   definition_store.update_from(source)
+    #   subject = definition_store.find_method_definition_by(
+    #     method_name: 'foo',
+    #     namespace: 'B',
+    #     singleton: false
+    #   )
+    #   expect(subject.qualified_name).to eq('A#foo')
+    # @example supports `prepend`
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         def foo
+    #         end
+    #       end
+    #
+    #       class B
+    #         prepend A
+    #
+    #         def foo
+    #         end
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   definition_store.update_from(source)
+    #   subject = definition_store.find_method_definition_by(
+    #     method_name: 'foo',
+    #     namespace: 'B',
+    #     singleton: false
+    #   )
+    #   expect(subject.qualified_name).to eq('A#foo')
+    def find_method_definition_by(
+      method_name:,
+      namespace:,
+      singleton: false
+    )
+      definition = find_definition_by_qualified_name(namespace)
       return unless definition
 
-      [
-        namespace,
-        *ancestor_definitions_of(definition).map(&:fully_qualified_name)
-      ].find do |fully_qualified_name|
+      ancestors_of(definition).find do |ancestor|
         method_marker = singleton ? '.' : '#'
-        fully_qualified_method_name = [
-          fully_qualified_name,
+        qualified_method_name = [
+          ancestor.qualified_name,
           method_marker,
           method_name
         ].join
-        definition = find_definition_by_fully_qualified_name(fully_qualified_method_name)
-        break definition if definition
+        method_definition = find_definition_by_qualified_name(qualified_method_name)
+        break method_definition if method_definition
       end
     end
 
     # @param type [String]
     # @return [Array<Rucoa::Definitions::MethodDefinition>]
-    # @example includes ancestors' methods
+    # @example supports simple instance method
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       class A
+    #         def foo
+    #         end
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   definition_store.update_from(source)
+    #   subject = definition_store.instance_method_definitions_of('A')
+    #   expect(subject.map(&:qualified_name)).to eq(%w[A#foo])
+    # @example supports inheritance
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       class A
+    #         def foo
+    #         end
+    #       end
+    #
+    #       class B < A
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   definition_store.update_from(source)
+    #   subject = definition_store.instance_method_definitions_of('B')
+    #   expect(subject.map(&:qualified_name)).to eq(%w[A#foo])
+    # @example supports `include`
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         def foo
+    #         end
+    #       end
+    #
+    #       class B
+    #         include A
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
     #   definition_store = Rucoa::DefinitionStore.new
-    #   definition_store.bulk_add(Rucoa::DefinitionArchiver.load)
-    #   subject = definition_store.instance_method_definitions_of('File')
-    #   expect(subject.map(&:fully_qualified_name)).to include('IO#raw')
-    # @example responds to `singleton<File>`
+    #   definition_store.update_from(source)
+    #   subject = definition_store.instance_method_definitions_of('B')
+    #   expect(subject.map(&:qualified_name)).to eq(%w[A#foo])
+    # @example supports `prepend`
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         def foo
+    #         end
+    #       end
+    #
+    #       class B
+    #         prepend A
+    #
+    #         def foo
+    #         end
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
     #   definition_store = Rucoa::DefinitionStore.new
-    #   definition_store.bulk_add(Rucoa::DefinitionArchiver.load)
-    #   subject = definition_store.instance_method_definitions_of('singleton<File>')
-    #   expect(subject.map(&:fully_qualified_name)).to include('IO.write')
+    #   definition_store.update_from(source)
+    #   subject = definition_store.instance_method_definitions_of('B')
+    #   expect(subject.map(&:qualified_name)).to eq(%w[A#foo])
     def instance_method_definitions_of(type)
       singleton_class_name = singleton_class_name_from(type)
       return singleton_method_definitions_of(singleton_class_name) if singleton_class_name
 
-      class_or_module_definition = find_definition_by_fully_qualified_name(type)
+      class_or_module_definition = find_definition_by_qualified_name(type)
       return [] unless class_or_module_definition
 
-      definitions = instance_method_definitions
-      [
-        class_or_module_definition,
-        *ancestor_definitions_of(class_or_module_definition)
-      ].map(&:fully_qualified_name).flat_map do |fully_qualified_type_name|
-        definitions.select do |definition|
-          definition.namespace == fully_qualified_type_name
+      method_definitions = self.method_definitions
+      ancestors_of(class_or_module_definition).flat_map do |ancestor|
+        method_definitions.select do |method_definition|
+          method_definition.namespace == ancestor.qualified_name &&
+            method_definition.instance_method?
         end
-      end
+      end.uniq(&:method_name)
     end
 
     # @param type [String]
     # @return [Array<Rucoa::Definitions::MethodDefinition>]
-    # @example returns singleton method definitions of File
+    # @example supports simple singleton method
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       class A
+    #         def self.foo
+    #         end
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   definition_store.update_from(source)
+    #   subject = definition_store.singleton_method_definitions_of('A')
+    #   expect(subject.map(&:qualified_name)).to include('A.foo')
+    # @example supports super class's singleton method
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       class A
+    #         def self.foo
+    #         end
+    #       end
+    #
+    #       class B < A
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
     #   definition_store = Rucoa::DefinitionStore.new
-    #   definition_store.bulk_add(Rucoa::DefinitionArchiver.load)
-    #   subject = definition_store.singleton_method_definitions_of('File')
-    #   expect(subject.map(&:fully_qualified_name)).to include('IO.write')
+    #   definition_store.update_from(source)
+    #   subject = definition_store.singleton_method_definitions_of('B')
+    #   expect(subject.map(&:qualified_name)).to include('A.foo')
+    # @example supports extended module's instance method
+    #   source = Rucoa::Source.new(
+    #     content: <<~RUBY,
+    #       module A
+    #         def foo
+    #         end
+    #       end
+    #
+    #       class B
+    #         def self.foo
+    #         end
+    #       end
+    #
+    #       class C < B
+    #         extend A
+    #       end
+    #     RUBY
+    #     uri: 'file:///path/to/example.rb'
+    #   )
+    #   definition_store = Rucoa::DefinitionStore.new
+    #   definition_store.update_from(source)
+    #   subject = definition_store.singleton_method_definitions_of('C')
+    #   expect(subject.map(&:qualified_name)).to eq(%w[A#foo])
     def singleton_method_definitions_of(type)
-      class_or_module_definition = find_definition_by_fully_qualified_name(type)
+      class_or_module_definition = find_definition_by_qualified_name(type)
       return [] unless class_or_module_definition
 
-      definitions = singleton_method_definitions
-      [
-        class_or_module_definition,
-        *ancestor_definitions_of(class_or_module_definition)
-      ].map(&:fully_qualified_name).flat_map do |fully_qualified_type_name|
-        definitions.select do |definition|
-          definition.namespace == fully_qualified_type_name
+      method_definitions = self.method_definitions
+      ancestors_of(class_or_module_definition).flat_map do |ancestor|
+        method_definitions.select do |method_definition|
+          method_definition.namespace == ancestor.qualified_name &&
+            method_definition.singleton_method?
+        end + ancestor.extended_module_qualified_names.flat_map do |extended_module_qualified_name|
+          method_definitions.select do |method_definition|
+            method_definition.namespace == extended_module_qualified_name &&
+              method_definition.instance_method?
+          end
         end
-      end
+      end.uniq(&:method_name)
     end
 
     # @param namespace [String]
@@ -159,42 +348,79 @@ module Rucoa
       end
     end
 
+    # @todo Search ancestors.
+    # @param unqualified_name [Rucoa::UnqualifiedName]
+    # @return [String]
+    def resolve_constant(unqualified_name)
+      (
+        unqualified_name.module_nesting.map do |prefix|
+          "#{prefix}::#{unqualified_name.chained_name}"
+        end + [unqualified_name.chained_name]
+      ).find do |candidate|
+        find_definition_by_qualified_name(candidate)
+      end || unqualified_name.chained_name
+    end
+
     private
 
     # @param source [Rucoa::Source]
     # @return [void]
-    def delete_definitions_about(source)
-      @fully_qualified_names_by_uri[source.uri].each do |fully_qualified_name|
-        @definition_by_full_qualified_name.delete(fully_qualified_name)
+    def delete_definitions_in(source)
+      @qualified_names_by_uri[source.uri].each do |qualified_name|
+        @definition_by_qualified_name.delete(qualified_name)
       end
-      @fully_qualified_names_by_uri.delete(source.uri)
+      @qualified_names_by_uri.delete(source.uri)
     end
 
     # @param type [String]
     # @return [String, nil]
     def singleton_class_name_from(type)
-      type[/singleton<(\w+)>/, 1]
+      type[/singleton<([\w:]+)>/, 1]
+    end
+
+    # @param definition [Rucoa::Definitions::Class, Rucoa::Definitions::Module]
+    # @return [Array<Rucoa::Definitions::Class>] The classes and modules that are traced in method search (as `Module#ancestors` in Ruby)
+    def ancestors_of(definition)
+      if definition.is_a?(Rucoa::Definitions::ClassDefinition)
+        [definition, *super_class_definitions_of(definition)]
+      else
+        [definition]
+      end.flat_map do |base|
+        module_ancestors_of(base)
+      end
     end
 
-    # @param class_or_module_definition [Rucoa::Definitions::Class, Rucoa::Definitions::Module]
-    # @return [Array<Rucoa::Definitions::Class>]
-    def ancestor_definitions_of(class_or_module_definition)
-      return [] unless class_or_module_definition.is_a?(Definitions::ClassDefinition)
+    # @param definition [Rucoa::Definitions::Class, Rucoa::Definitions::Module]
+    # @return [Array<Rucoa::Definitions::Class, Rucoa::Definitions::Module>] An array of prepended, itself, and included definitions
+    def module_ancestors_of(definition)
+      [
+        *definition.prepended_module_qualified_names.filter_map do |qualified_name|
+          find_definition_by_qualified_name(qualified_name)
+        end.reverse,
+        definition,
+        *definition.included_module_qualified_names.filter_map do |qualified_name|
+          find_definition_by_qualified_name(qualified_name)
+        end.reverse
+      ]
+    end
 
+    # @param definition [Rucoa::Definitions::Class]
+    # @return [Array<Rucoa::Definitions::Class>] super "class"es (not including modules) in closest-first order
+    def super_class_definitions_of(definition)
       result = []
-      class_definition = class_or_module_definition
-      while (super_class_fully_qualified_name = class_definition.super_class_fully_qualified_name)
-        class_definition = find_definition_by_fully_qualified_name(super_class_fully_qualified_name)
-        break unless class_definition
+      while (super_class_qualified_name = definition.super_class_qualified_name)
+        super_definition = find_definition_by_qualified_name(super_class_qualified_name)
+        break unless super_definition
 
-        result << class_definition
+        result << super_definition
+        definition = super_definition
       end
       result
     end
 
     # @return [Array<Rucoa::Definitions::Base>]
     def definitions
-      @definition_by_full_qualified_name.values
+      @definition_by_qualified_name.values
     end
 
     # @return [Array<Rucoa::Definition::MethodDefinition>]
@@ -202,29 +428,48 @@ module Rucoa
       definitions.grep(Definitions::MethodDefinition)
     end
 
-    # @return [Array<Rucoa::Definition::MethodDefinition>]
-    def instance_method_definitions
-      method_definitions.select(&:instance_method?)
-    end
-
-    # @return [Array<Rucoa::Definition::MethodDefinition>]
-    def singleton_method_definitions
-      method_definitions.select(&:singleton_method?)
-    end
-
     # @return [Array<Rucoa::Definition::ConstantDefinition>]
     def constant_definitions
       definitions.grep(Definitions::ConstantDefinition)
     end
 
-    # @param class_definition [Rucoa::Definitions::ClassDefinition]
-    # @return [String]
-    def resolve_super_class_of(class_definition)
-      return 'Object' unless class_definition.super_class_chained_name
+    # @param source [Rucoa::Source]
+    # @return [void]
+    def add_definitions_in(source)
+      source.definitions.group_by do |definition|
+        definition.location.uri
+      end.each do |uri, definitions|
+        @qualified_names_by_uri[uri] += definitions.map(&:qualified_name)
+        definitions.each do |definition|
+          @definition_by_qualified_name[definition.qualified_name] = definition
+        end
+      end
+    end
+
+    # @param source [Rucoa::Source]
+    # @return [void]
+    def resolve_constants_in(source)
+      source.definitions.each do |definition|
+        next unless definition.is_a?(Definitions::ClassDefinition)
+
+        definition.super_class_qualified_name = resolve_constant(definition.super_class_unqualified_name)
+        definition.super_class_unqualified_name = nil
+
+        definition.extended_module_qualified_names = definition.extended_module_unqualified_names.map do |unqualified_name|
+          resolve_constant(unqualified_name)
+        end
+        definition.extended_module_unqualified_names = []
 
-      class_definition.super_class_candidates.find do |candidate|
-        find_definition_by_fully_qualified_name(candidate)
-      end || class_definition.super_class_chained_name
+        definition.included_module_qualified_names = definition.included_module_unqualified_names.map do |unqualified_name|
+          resolve_constant(unqualified_name)
+        end
+        definition.included_module_unqualified_names = []
+
+        definition.prepended_module_qualified_names = definition.prepended_module_unqualified_names.map do |unqualified_name|
+          resolve_constant(unqualified_name)
+        end
+        definition.prepended_module_unqualified_names = []
+      end
     end
   end
 end

data/lib/rucoa/definitions/base.rb

@@ -3,9 +3,20 @@
 module Rucoa
   module Definitions
     class Base
-      # @return [String]
-      def source_path
-        raise ::NotImplementedError
+      # @return [String, nil]
+      attr_reader :description
+
+      # @return [Rucoa::Location, nil]
+      attr_accessor :location
+
+      # @param description [String, nil]
+      # @param location [Rucoa::Location, nil]
+      def initialize(
+        description:,
+        location:
+      )
+        @description = description
+        @location = location
       end
     end
   end