Class: Yoda::Model::TypeExpressions::GenericType

Inherits:
Base
  • Object
show all
Defined in:
lib/yoda/model/type_expressions/generic_type.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Base

#==

Constructor Details

#initialize(base_type, type_arguments) ⇒ GenericType

Returns a new instance of GenericType.

Parameters:



26
27
28
29
 
# File 'lib/yoda/model/type_expressions/generic_type.rb', line 26

def initialize(base_type, type_arguments)
  @base_type = base_type
  @type_arguments = type_arguments
end

Instance Attribute Details

#base_type ⇒ Base (readonly)

Returns:



6
7
8
 
# File 'lib/yoda/model/type_expressions/generic_type.rb', line 6

def base_type
  @base_type
end

#type_arguments ⇒ Array<Base> (readonly)

Returns:



9
10
11
 
# File 'lib/yoda/model/type_expressions/generic_type.rb', line 9

def type_arguments
  @type_arguments
end

Class Method Details

.from_key_value(base_type, key_type, value_type) ⇒ Object

Parameters:



14
15
16
 
# File 'lib/yoda/model/type_expressions/generic_type.rb', line 14

def self.from_key_value(base_type, key_type, value_type)
  new(base_type, [key_type, value_type])
end

Instance Method Details

#change_root(namespace) ⇒ GenericType

Parameters:

  • namespace (YARD::CodeObjects::Base)

Returns:



20
21
22
 
# File 'lib/yoda/model/type_expressions/generic_type.rb', line 20

def change_root(paths)
  self.class.new(base_type.change_root(paths), type_arguments.map { |type| type.change_root(paths) })
end

#eql?(another) ⇒ Boolean

Parameters:

  • another (Object)

Returns:

  • (Boolean) 


32
33
34
35
36
 
# File 'lib/yoda/model/type_expressions/generic_type.rb', line 32

def eql?(another)
  another.is_a?(GenericType) &&
  base_type  == another.base_type &&
  type_arguments == another.type_arguments
end

#hash ⇒ Object 



38
39
40
 
# File 'lib/yoda/model/type_expressions/generic_type.rb', line 38

def hash
  [self.class.name, base_type, type_arguments].hash
end

#map(&block) ⇒ self

Returns:

  • (self) 


75
76
77
 
# File 'lib/yoda/model/type_expressions/generic_type.rb', line 75

def map(&block)
  self.class.new(base_type.map(&block), type_arguments.map(&block))
end

#resolve(registry) ⇒ Array<YARD::CodeObjects::Base, YARD::CodeObjects::Proxy>

Parameters:

  • registry (Registry)

Returns:

  • (Array<YARD::CodeObjects::Base, YARD::CodeObjects::Proxy>) 


50
51
52
 
# File 'lib/yoda/model/type_expressions/generic_type.rb', line 50

def resolve(registry)
  base_type.resolve(registry)
end

#to_rbs_type(env) ⇒ Object

Parameters:



60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/yoda/model/type_expressions/generic_type.rb', line 60

def to_rbs_type(env)
  type_args = type_arguments.map { |t| t.to_rbs_type(env) }
  case base_type
  when InstanceType
    name = env.resolve_rbs_type_name(base_type.path)
    name ? RBS::Types::ClassInstance.new(name: name, args: type_args, location: nil) : RBS::Types::Bases::Any.new(location: nil)
  when ModuleType
    name = env.resolve_rbs_type_name(base_type.path)
    name ? RBS::Types::Interface.new(name: name, args: type_args, location: nil) : RBS::Types::Bases::Any.new(location: nil)
  else
    inner_type = base_type.to_rbs_type(env)
  end
end

#to_s ⇒ String

Returns:

  • (String) 


55
56
57
 
# File 'lib/yoda/model/type_expressions/generic_type.rb', line 55

def to_s
  "#{base_type}<#{type_arguments.map(&:to_s).join(', ')}>"
end