Class: Yoda::Model::Types::FunctionType

Inherits:
Base
  • Object
show all
Defined in:
lib/yoda/model/types/function_type.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods inherited from Base

#==

Constructor Details

#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) ⇒ FunctionType

Returns a new instance of FunctionType.

Parameters:

  • context (Base, nil) (defaults to: nil)
  • required_parameters (Array<Base>) (defaults to: [])
  • optional_parameters (Array<Base>) (defaults to: [])
  • rest_parameter (Base, nil) (defaults to: nil)
  • post_parameters (Array<Base>) (defaults to: [])
  • keyword_parameters (Array<(String, Base)>)
  • keyword_rest_parameter (Base, nil) (defaults to: nil)
  • block_parameter (Base, nil) (defaults to: nil)
  • return_type (Base) 


32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/yoda/model/types/function_type.rb', line 32

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

Instance Attribute Details

#block_parameter ⇒ Base? (readonly)

Returns:



18
19
20
 
# File 'lib/yoda/model/types/function_type.rb', line 18

def block_parameter
  @block_parameter
end

#context ⇒ Base? (readonly)

Returns:



6
7
8
 
# File 'lib/yoda/model/types/function_type.rb', line 6

def context
  @context
end

#keyword_rest_parameter ⇒ Base? (readonly)

Returns:



18
19
20
 
# File 'lib/yoda/model/types/function_type.rb', line 18

def keyword_rest_parameter
  @keyword_rest_parameter
end

#optional_keyword_parameters ⇒ Array<(String, Base)> (readonly)

Returns:

  • (Array<(String, Base)>) 


15
16
17
 
# File 'lib/yoda/model/types/function_type.rb', line 15

def optional_keyword_parameters
  @optional_keyword_parameters
end

#optional_parameters ⇒ Array<Base> (readonly)

Returns:



9
10
11
 
# File 'lib/yoda/model/types/function_type.rb', line 9

def optional_parameters
  @optional_parameters
end

#post_parameters ⇒ Array<Base> (readonly)

Returns:



9
10
11
 
# File 'lib/yoda/model/types/function_type.rb', line 9

def post_parameters
  @post_parameters
end

#required_keyword_parameters ⇒ Array<(String, Base)> (readonly)

Returns:

  • (Array<(String, Base)>) 


12
13
14
 
# File 'lib/yoda/model/types/function_type.rb', line 12

def required_keyword_parameters
  @required_keyword_parameters
end

#required_parameters ⇒ Array<Base> (readonly)

Returns:



9
10
11
 
# File 'lib/yoda/model/types/function_type.rb', line 9

def required_parameters
  @required_parameters
end

#rest_parameter ⇒ Base? (readonly)

Returns:



18
19
20
 
# File 'lib/yoda/model/types/function_type.rb', line 18

def rest_parameter
  @rest_parameter
end

#return_type ⇒ Base (readonly)

Returns:



21
22
23
 
# File 'lib/yoda/model/types/function_type.rb', line 21

def return_type
  @return_type
end

Instance Method Details

#change_root(namespace) ⇒ UnionType

Parameters:

  • namespace (YARD::CodeObjects::Base)

Returns:



77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/yoda/model/types/function_type.rb', line 77

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

#eql?(another) ⇒ Boolean

Returns:

  • (Boolean) 


45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/yoda/model/types/function_type.rb', line 45

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

#hash ⇒ Object 



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

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

#map(&block) ⇒ self

Returns:

  • (self) 


109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/yoda/model/types/function_type.rb', line 109

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

#method_type_signature ⇒ Object 



98
99
100
101
 
# File 'lib/yoda/model/types/function_type.rb', line 98

def method_type_signature
  params_str = all_parameters_to_s
  (params_str.empty? ? ': ' : "(#{params_str}): ") + "#{return_type}"
end

#resolve(registry) ⇒ Array<Store::Objects::Base>

Parameters:

  • registry (Registry)

Returns:



94
95
96
 
# File 'lib/yoda/model/types/function_type.rb', line 94

def resolve(registry)
  []
end

#to_s ⇒ Object 



103
104
105
106
 
# File 'lib/yoda/model/types/function_type.rb', line 103

def to_s
  params_str = all_parameters_to_s
  (params_str.empty? ? '' : "(#{params_str}) -> ") + "#{return_type}"
end