Class: Yoda::Model::Parameters::Binder::BoundResult

Inherits:
Object
  • Object
show all
Defined in:
lib/yoda/model/parameters/binder.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(type:, parameter:, generator:) ⇒ BoundResult

Returns a new instance of BoundResult.

Parameters:



45
46
47
48
49
 
# File 'lib/yoda/model/parameters/binder.rb', line 45

def initialize(type:, parameter:, generator:)
  @type = type
  @parameter = parameter
  @generator = generator
end

Instance Attribute Details

#generator ⇒ Generator (readonly)

Returns:



40
41
42
 
# File 'lib/yoda/model/parameters/binder.rb', line 40

def generator
  @generator
end

#parameter ⇒ Model::Parameters::Base (readonly)

Returns:



37
38
39
 
# File 'lib/yoda/model/parameters/binder.rb', line 37

def parameter
  @parameter
end

#type ⇒ Interface (readonly)

Returns:

  • (Interface) 


34
35
36
 
# File 'lib/yoda/model/parameters/binder.rb', line 34

def type
  @type
end

Instance Method Details

#block_parameter ⇒ Hash{Symbol => Interface}

Returns:

  • (Hash{Symbol => Interface}) 


111
112
113
 
# File 'lib/yoda/model/parameters/binder.rb', line 111

def block_parameter
  @block_parameter ||= parameter.block_parameter ? bind_param(parameter.block_parameter, type.block_parameter || generator.proc_type) : {}
end

#keyword_parameter_bindings ⇒ Hash{Symbol => Interface}

Returns:

  • (Hash{Symbol => Interface}) 


86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/yoda/model/parameters/binder.rb', line 86

def keyword_parameter_bindings
  @keyword_parameter_bindings ||= begin
    type_hash = type.keyword_parameters.to_h
    dict = parameter.keyword_parameters.reduce({}) do |dict, param|
      if name = (param.respond_to?(:name) && param.name)
        dict.merge(name => type_hash.delete(param) || generator.any_type)
      else
        dict
      end
    end

    if parameter.keyword_rest_parameter
      if type_hash.empty?
        dict = dict.merge(bind_param(parameter.keyword_rest_parameter, type.keyword_rest_parameter || generator.hash_type))
      else
        # TODO: merge
        dict = dict.merge(bind_param(parameter.keyword_rest_parameter, generator.hash_type))
      end
    end

    dict
  end
end

#parameter_bindings ⇒ Hash{Symbol => Interface}

Returns:

  • (Hash{Symbol => Interface}) 


60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/yoda/model/parameters/binder.rb', line 60

def parameter_bindings
  @parameter_bindings ||= begin
    dict, parameters_remain, types_remain = bind_params_as_possible(parameter.parameters, type.parameters)
    # TODO: bind with rest paremter type
    dict = parameters_remain.reduce(dict) { |dict, param| dict.merge(bind_param(param, generator.any_type)) }

    postdict, post_parameters_remain, post_types_remain = bind_params_as_possible(parameter.post_parameters.reverse, type.post_parameters.reverse)
    dict = dict.merge(postdict)
    # TODO: bind with rest paremter type
    dict = post_parameters_remain.reduce(dict) { |dict, param| dict.merge(bind_param(param, generator.any_type)) }

    if parameter.rest_parameter
      if types_remain.empty? && post_types_remain.empty?
        # TODO: bind rest things of keyword and block binding
        dict = dict.merge(bind_param(parameter.rest_parameter, type.rest_parameter || generator.array_type))
      else
        # TODO: bind as sequence type
        dict = dict.merge(bind_param(parameter.rest_parameter, generator.array_type))
      end
    end

    dict
  end
end

#type_bindings ⇒ Hash{Symbol => Interface}

Returns:

  • (Hash{Symbol => Interface}) 


52
53
54
55
56
57
 
# File 'lib/yoda/model/parameters/binder.rb', line 52

def type_bindings
  @type_bindings ||= {}
    .merge!(parameter_bindings)
    .merge!(keyword_parameter_bindings)
    .merge!(block_parameter)
end