puppet 5.0.1-x86-mingw32 → 5.1.0-x86-mingw32

Sign up to get free protection for your applications and to get access to all the features.

Potentially problematic release.


This version of puppet might be problematic. Click here for more details.

Files changed (105) hide show
  1. checksums.yaml +4 -4
  2. data/lib/puppet/agent.rb +1 -0
  3. data/lib/puppet/defaults.rb +1 -1
  4. data/lib/puppet/functions.rb +6 -7
  5. data/lib/puppet/functions/all.rb +100 -0
  6. data/lib/puppet/functions/any.rb +105 -0
  7. data/lib/puppet/functions/defined.rb +3 -3
  8. data/lib/puppet/functions/new.rb +2 -1
  9. data/lib/puppet/functions/reduce.rb +31 -0
  10. data/lib/puppet/functions/tree_each.rb +200 -0
  11. data/lib/puppet/module.rb +30 -0
  12. data/lib/puppet/parser/functions/new.rb +67 -0
  13. data/lib/puppet/parser/functions/reduce.rb +31 -0
  14. data/lib/puppet/parser/relationship.rb +2 -2
  15. data/lib/puppet/parser/resource.rb +39 -10
  16. data/lib/puppet/parser/scope.rb +1 -1
  17. data/lib/puppet/pops/evaluator/access_operator.rb +11 -4
  18. data/lib/puppet/pops/evaluator/collector_transformer.rb +1 -1
  19. data/lib/puppet/pops/evaluator/evaluator_impl.rb +4 -4
  20. data/lib/puppet/pops/evaluator/relationship_operator.rb +1 -1
  21. data/lib/puppet/pops/evaluator/runtime3_converter.rb +3 -3
  22. data/lib/puppet/pops/evaluator/runtime3_resource_support.rb +1 -1
  23. data/lib/puppet/pops/loader/module_loaders.rb +1 -1
  24. data/lib/puppet/pops/loader/static_loader.rb +1 -2
  25. data/lib/puppet/pops/loaders.rb +1 -2
  26. data/lib/puppet/pops/lookup/context.rb +1 -1
  27. data/lib/puppet/pops/lookup/lookup_adapter.rb +2 -1
  28. data/lib/puppet/pops/model/ast.rb +440 -436
  29. data/lib/puppet/pops/model/factory.rb +140 -140
  30. data/lib/puppet/pops/pcore.rb +1 -2
  31. data/lib/puppet/pops/resource/param.rb +1 -1
  32. data/lib/puppet/pops/resource/resource_type_impl.rb +1 -1
  33. data/lib/puppet/pops/serialization/from_data_converter.rb +0 -12
  34. data/lib/puppet/pops/time/timestamp.rb +29 -17
  35. data/lib/puppet/pops/types/annotatable.rb +2 -2
  36. data/lib/puppet/pops/types/annotation.rb +8 -8
  37. data/lib/puppet/pops/types/class_loader.rb +3 -3
  38. data/lib/puppet/pops/types/implementation_registry.rb +1 -1
  39. data/lib/puppet/pops/types/iterable.rb +2 -2
  40. data/lib/puppet/pops/types/p_binary_type.rb +2 -2
  41. data/lib/puppet/pops/types/p_init_type.rb +238 -0
  42. data/lib/puppet/pops/types/p_meta_type.rb +14 -11
  43. data/lib/puppet/pops/types/p_object_type.rb +15 -15
  44. data/lib/puppet/pops/types/p_sem_ver_range_type.rb +2 -2
  45. data/lib/puppet/pops/types/p_sem_ver_type.rb +2 -2
  46. data/lib/puppet/pops/types/p_sensitive_type.rb +2 -2
  47. data/lib/puppet/pops/types/p_timespan_type.rb +6 -6
  48. data/lib/puppet/pops/types/p_timestamp_type.rb +6 -2
  49. data/lib/puppet/pops/types/p_type_set_type.rb +10 -9
  50. data/lib/puppet/pops/types/ruby_generator.rb +6 -5
  51. data/lib/puppet/pops/types/ruby_method.rb +2 -2
  52. data/lib/puppet/pops/types/string_converter.rb +1 -1
  53. data/lib/puppet/pops/types/tree_iterators.rb +250 -0
  54. data/lib/puppet/pops/types/type_calculator.rb +13 -13
  55. data/lib/puppet/pops/types/type_factory.rb +26 -7
  56. data/lib/puppet/pops/types/type_formatter.rb +9 -4
  57. data/lib/puppet/pops/types/type_parser.rb +8 -3
  58. data/lib/puppet/pops/types/type_set_reference.rb +2 -2
  59. data/lib/puppet/pops/types/types.rb +168 -109
  60. data/lib/puppet/provider/package/gem.rb +10 -9
  61. data/lib/puppet/provider/package/pip.rb +12 -3
  62. data/lib/puppet/provider/package/yum.rb +9 -1
  63. data/lib/puppet/resource/capability_finder.rb +30 -11
  64. data/lib/puppet/type/file.rb +21 -13
  65. data/lib/puppet/util/execution.rb +67 -14
  66. data/lib/puppet/util/suidmanager.rb +1 -0
  67. data/lib/puppet/version.rb +1 -1
  68. data/locales/puppet.pot +130 -66
  69. data/man/man5/puppet.conf.5 +1 -1
  70. data/spec/fixtures/unit/provider/package/yum/yum-check-update-simple.txt +1 -0
  71. data/spec/integration/parser/collection_spec.rb +40 -1
  72. data/spec/shared_contexts/types_setup.rb +41 -2
  73. data/spec/unit/agent_spec.rb +11 -0
  74. data/spec/unit/file_bucket/dipper_spec.rb +13 -4
  75. data/spec/unit/functions/all_spec.rb +97 -0
  76. data/spec/unit/functions/any_spec.rb +109 -0
  77. data/spec/unit/functions/hiera_spec.rb +5 -0
  78. data/spec/unit/functions/new_spec.rb +66 -0
  79. data/spec/unit/functions/tree_each_spec.rb +444 -0
  80. data/spec/unit/module_spec.rb +29 -0
  81. data/spec/unit/pops/serialization/serialization_spec.rb +2 -2
  82. data/spec/unit/pops/serialization/to_from_hr_spec.rb +2 -2
  83. data/spec/unit/pops/types/iterable_spec.rb +9 -9
  84. data/spec/unit/pops/types/p_init_type_spec.rb +285 -0
  85. data/spec/unit/pops/types/p_object_type_spec.rb +8 -8
  86. data/spec/unit/pops/types/p_sensitive_type_spec.rb +4 -0
  87. data/spec/unit/pops/types/p_timespan_type_spec.rb +14 -0
  88. data/spec/unit/pops/types/p_timestamp_type_spec.rb +19 -1
  89. data/spec/unit/pops/types/p_type_set_type_spec.rb +2 -2
  90. data/spec/unit/pops/types/ruby_generator_spec.rb +9 -22
  91. data/spec/unit/pops/types/string_converter_spec.rb +2 -2
  92. data/spec/unit/pops/types/type_acceptor_spec.rb +2 -2
  93. data/spec/unit/pops/types/type_calculator_spec.rb +43 -38
  94. data/spec/unit/pops/types/type_factory_spec.rb +6 -6
  95. data/spec/unit/pops/types/type_formatter_spec.rb +6 -6
  96. data/spec/unit/pops/types/types_spec.rb +16 -4
  97. data/spec/unit/provider/package/gem_spec.rb +6 -6
  98. data/spec/unit/provider/package/pip_spec.rb +44 -23
  99. data/spec/unit/provider/package/puppet_gem_spec.rb +1 -1
  100. data/spec/unit/provider/package/yum_spec.rb +8 -0
  101. data/spec/unit/resource/capability_finder_spec.rb +4 -5
  102. data/spec/unit/type/file_spec.rb +19 -14
  103. data/spec/unit/util/execution_spec.rb +216 -82
  104. data/tasks/generate_ast_model.rake +10 -2
  105. metadata +15 -2
@@ -68,7 +68,8 @@ class LookupAdapter < DataAdapter
68
68
  end
69
69
 
70
70
  def lookup_global(key, lookup_invocation, merge_strategy)
71
- terminus = Puppet[:data_binding_terminus]
71
+ # hiera_xxx will always use global_provider regardless of data_binding_terminus setting
72
+ terminus = lookup_invocation.hiera_xxx_call? ? :hiera : Puppet[:data_binding_terminus]
72
73
  case terminus
73
74
  when :hiera, 'hiera'
74
75
  provider = global_provider(lookup_invocation)
@@ -11,11 +11,11 @@ class PopsObject
11
11
 
12
12
  include Types::PuppetObject
13
13
 
14
- def self.from_hash(i12n)
15
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::PopsObject initializer', _pcore_type.i12n_type, i12n))
14
+ def self.from_hash(init_hash)
15
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::PopsObject initializer', _pcore_type.init_hash_type, init_hash))
16
16
  end
17
17
 
18
- def self.from_asserted_hash(i12n)
18
+ def self.from_asserted_hash(init_hash)
19
19
  new
20
20
  end
21
21
 
@@ -25,7 +25,7 @@ class PopsObject
25
25
  attr_reader :hash
26
26
 
27
27
  def initialize
28
- @hash = -1052386662549381418
28
+ @hash = -1631630444118989922
29
29
  end
30
30
  def _pcore_init_hash
31
31
  {}
@@ -75,15 +75,15 @@ class Positioned < PopsObject
75
75
  })
76
76
  end
77
77
 
78
- def self.from_hash(i12n)
79
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::Positioned initializer', _pcore_type.i12n_type, i12n))
78
+ def self.from_hash(init_hash)
79
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::Positioned initializer', _pcore_type.init_hash_type, init_hash))
80
80
  end
81
81
 
82
- def self.from_asserted_hash(i12n)
82
+ def self.from_asserted_hash(init_hash)
83
83
  new(
84
- i12n['locator'],
85
- i12n['offset'],
86
- i12n['length'])
84
+ init_hash['locator'],
85
+ init_hash['offset'],
86
+ init_hash['length'])
87
87
  end
88
88
 
89
89
  def self.create(locator, offset, length)
@@ -154,17 +154,17 @@ class BinaryExpression < Expression
154
154
  })
155
155
  end
156
156
 
157
- def self.from_hash(i12n)
158
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::BinaryExpression initializer', _pcore_type.i12n_type, i12n))
157
+ def self.from_hash(init_hash)
158
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::BinaryExpression initializer', _pcore_type.init_hash_type, init_hash))
159
159
  end
160
160
 
161
- def self.from_asserted_hash(i12n)
161
+ def self.from_asserted_hash(init_hash)
162
162
  new(
163
- i12n['locator'],
164
- i12n['offset'],
165
- i12n['length'],
166
- i12n['left_expr'],
167
- i12n['right_expr'])
163
+ init_hash['locator'],
164
+ init_hash['offset'],
165
+ init_hash['length'],
166
+ init_hash['left_expr'],
167
+ init_hash['right_expr'])
168
168
  end
169
169
 
170
170
  def self.create(locator, offset, length, left_expr, right_expr)
@@ -231,16 +231,16 @@ class UnaryExpression < Expression
231
231
  })
232
232
  end
233
233
 
234
- def self.from_hash(i12n)
235
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::UnaryExpression initializer', _pcore_type.i12n_type, i12n))
234
+ def self.from_hash(init_hash)
235
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::UnaryExpression initializer', _pcore_type.init_hash_type, init_hash))
236
236
  end
237
237
 
238
- def self.from_asserted_hash(i12n)
238
+ def self.from_asserted_hash(init_hash)
239
239
  new(
240
- i12n['locator'],
241
- i12n['offset'],
242
- i12n['length'],
243
- i12n['expr'])
240
+ init_hash['locator'],
241
+ init_hash['offset'],
242
+ init_hash['length'],
243
+ init_hash['expr'])
244
244
  end
245
245
 
246
246
  def self.create(locator, offset, length, expr)
@@ -381,18 +381,18 @@ class AssignmentExpression < BinaryExpression
381
381
  })
382
382
  end
383
383
 
384
- def self.from_hash(i12n)
385
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::AssignmentExpression initializer', _pcore_type.i12n_type, i12n))
384
+ def self.from_hash(init_hash)
385
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::AssignmentExpression initializer', _pcore_type.init_hash_type, init_hash))
386
386
  end
387
387
 
388
- def self.from_asserted_hash(i12n)
388
+ def self.from_asserted_hash(init_hash)
389
389
  new(
390
- i12n['locator'],
391
- i12n['offset'],
392
- i12n['length'],
393
- i12n['left_expr'],
394
- i12n['right_expr'],
395
- i12n['operator'])
390
+ init_hash['locator'],
391
+ init_hash['offset'],
392
+ init_hash['length'],
393
+ init_hash['left_expr'],
394
+ init_hash['right_expr'],
395
+ init_hash['operator'])
396
396
  end
397
397
 
398
398
  def self.create(locator, offset, length, left_expr, right_expr, operator)
@@ -456,18 +456,18 @@ class ArithmeticExpression < BinaryExpression
456
456
  })
457
457
  end
458
458
 
459
- def self.from_hash(i12n)
460
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::ArithmeticExpression initializer', _pcore_type.i12n_type, i12n))
459
+ def self.from_hash(init_hash)
460
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::ArithmeticExpression initializer', _pcore_type.init_hash_type, init_hash))
461
461
  end
462
462
 
463
- def self.from_asserted_hash(i12n)
463
+ def self.from_asserted_hash(init_hash)
464
464
  new(
465
- i12n['locator'],
466
- i12n['offset'],
467
- i12n['length'],
468
- i12n['left_expr'],
469
- i12n['right_expr'],
470
- i12n['operator'])
465
+ init_hash['locator'],
466
+ init_hash['offset'],
467
+ init_hash['length'],
468
+ init_hash['left_expr'],
469
+ init_hash['right_expr'],
470
+ init_hash['operator'])
471
471
  end
472
472
 
473
473
  def self.create(locator, offset, length, left_expr, right_expr, operator)
@@ -531,18 +531,18 @@ class RelationshipExpression < BinaryExpression
531
531
  })
532
532
  end
533
533
 
534
- def self.from_hash(i12n)
535
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::RelationshipExpression initializer', _pcore_type.i12n_type, i12n))
534
+ def self.from_hash(init_hash)
535
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::RelationshipExpression initializer', _pcore_type.init_hash_type, init_hash))
536
536
  end
537
537
 
538
- def self.from_asserted_hash(i12n)
538
+ def self.from_asserted_hash(init_hash)
539
539
  new(
540
- i12n['locator'],
541
- i12n['offset'],
542
- i12n['length'],
543
- i12n['left_expr'],
544
- i12n['right_expr'],
545
- i12n['operator'])
540
+ init_hash['locator'],
541
+ init_hash['offset'],
542
+ init_hash['length'],
543
+ init_hash['left_expr'],
544
+ init_hash['right_expr'],
545
+ init_hash['operator'])
546
546
  end
547
547
 
548
548
  def self.create(locator, offset, length, left_expr, right_expr, operator)
@@ -610,17 +610,17 @@ class AccessExpression < Expression
610
610
  })
611
611
  end
612
612
 
613
- def self.from_hash(i12n)
614
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::AccessExpression initializer', _pcore_type.i12n_type, i12n))
613
+ def self.from_hash(init_hash)
614
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::AccessExpression initializer', _pcore_type.init_hash_type, init_hash))
615
615
  end
616
616
 
617
- def self.from_asserted_hash(i12n)
617
+ def self.from_asserted_hash(init_hash)
618
618
  new(
619
- i12n['locator'],
620
- i12n['offset'],
621
- i12n['length'],
622
- i12n['left_expr'],
623
- i12n.fetch('keys') { _pcore_type['keys'].value })
619
+ init_hash['locator'],
620
+ init_hash['offset'],
621
+ init_hash['length'],
622
+ init_hash['left_expr'],
623
+ init_hash.fetch('keys') { _pcore_type['keys'].value })
624
624
  end
625
625
 
626
626
  def self.create(locator, offset, length, left_expr, keys = _pcore_type['keys'].value)
@@ -687,18 +687,18 @@ class ComparisonExpression < BinaryExpression
687
687
  })
688
688
  end
689
689
 
690
- def self.from_hash(i12n)
691
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::ComparisonExpression initializer', _pcore_type.i12n_type, i12n))
690
+ def self.from_hash(init_hash)
691
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::ComparisonExpression initializer', _pcore_type.init_hash_type, init_hash))
692
692
  end
693
693
 
694
- def self.from_asserted_hash(i12n)
694
+ def self.from_asserted_hash(init_hash)
695
695
  new(
696
- i12n['locator'],
697
- i12n['offset'],
698
- i12n['length'],
699
- i12n['left_expr'],
700
- i12n['right_expr'],
701
- i12n['operator'])
696
+ init_hash['locator'],
697
+ init_hash['offset'],
698
+ init_hash['length'],
699
+ init_hash['left_expr'],
700
+ init_hash['right_expr'],
701
+ init_hash['operator'])
702
702
  end
703
703
 
704
704
  def self.create(locator, offset, length, left_expr, right_expr, operator)
@@ -762,18 +762,18 @@ class MatchExpression < BinaryExpression
762
762
  })
763
763
  end
764
764
 
765
- def self.from_hash(i12n)
766
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::MatchExpression initializer', _pcore_type.i12n_type, i12n))
765
+ def self.from_hash(init_hash)
766
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::MatchExpression initializer', _pcore_type.init_hash_type, init_hash))
767
767
  end
768
768
 
769
- def self.from_asserted_hash(i12n)
769
+ def self.from_asserted_hash(init_hash)
770
770
  new(
771
- i12n['locator'],
772
- i12n['offset'],
773
- i12n['length'],
774
- i12n['left_expr'],
775
- i12n['right_expr'],
776
- i12n['operator'])
771
+ init_hash['locator'],
772
+ init_hash['offset'],
773
+ init_hash['length'],
774
+ init_hash['left_expr'],
775
+ init_hash['right_expr'],
776
+ init_hash['operator'])
777
777
  end
778
778
 
779
779
  def self.create(locator, offset, length, left_expr, right_expr, operator)
@@ -944,16 +944,16 @@ class LiteralList < Expression
944
944
  })
945
945
  end
946
946
 
947
- def self.from_hash(i12n)
948
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::LiteralList initializer', _pcore_type.i12n_type, i12n))
947
+ def self.from_hash(init_hash)
948
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::LiteralList initializer', _pcore_type.init_hash_type, init_hash))
949
949
  end
950
950
 
951
- def self.from_asserted_hash(i12n)
951
+ def self.from_asserted_hash(init_hash)
952
952
  new(
953
- i12n['locator'],
954
- i12n['offset'],
955
- i12n['length'],
956
- i12n.fetch('values') { _pcore_type['values'].value })
953
+ init_hash['locator'],
954
+ init_hash['offset'],
955
+ init_hash['length'],
956
+ init_hash.fetch('values') { _pcore_type['values'].value })
957
957
  end
958
958
 
959
959
  def self.create(locator, offset, length, values = _pcore_type['values'].value)
@@ -1011,17 +1011,17 @@ class KeyedEntry < Positioned
1011
1011
  })
1012
1012
  end
1013
1013
 
1014
- def self.from_hash(i12n)
1015
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::KeyedEntry initializer', _pcore_type.i12n_type, i12n))
1014
+ def self.from_hash(init_hash)
1015
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::KeyedEntry initializer', _pcore_type.init_hash_type, init_hash))
1016
1016
  end
1017
1017
 
1018
- def self.from_asserted_hash(i12n)
1018
+ def self.from_asserted_hash(init_hash)
1019
1019
  new(
1020
- i12n['locator'],
1021
- i12n['offset'],
1022
- i12n['length'],
1023
- i12n['key'],
1024
- i12n['value'])
1020
+ init_hash['locator'],
1021
+ init_hash['offset'],
1022
+ init_hash['length'],
1023
+ init_hash['key'],
1024
+ init_hash['value'])
1025
1025
  end
1026
1026
 
1027
1027
  def self.create(locator, offset, length, key, value)
@@ -1091,16 +1091,16 @@ class LiteralHash < Expression
1091
1091
  })
1092
1092
  end
1093
1093
 
1094
- def self.from_hash(i12n)
1095
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::LiteralHash initializer', _pcore_type.i12n_type, i12n))
1094
+ def self.from_hash(init_hash)
1095
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::LiteralHash initializer', _pcore_type.init_hash_type, init_hash))
1096
1096
  end
1097
1097
 
1098
- def self.from_asserted_hash(i12n)
1098
+ def self.from_asserted_hash(init_hash)
1099
1099
  new(
1100
- i12n['locator'],
1101
- i12n['offset'],
1102
- i12n['length'],
1103
- i12n.fetch('entries') { _pcore_type['entries'].value })
1100
+ init_hash['locator'],
1101
+ init_hash['offset'],
1102
+ init_hash['length'],
1103
+ init_hash.fetch('entries') { _pcore_type['entries'].value })
1104
1104
  end
1105
1105
 
1106
1106
  def self.create(locator, offset, length, entries = _pcore_type['entries'].value)
@@ -1160,16 +1160,16 @@ class BlockExpression < Expression
1160
1160
  })
1161
1161
  end
1162
1162
 
1163
- def self.from_hash(i12n)
1164
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::BlockExpression initializer', _pcore_type.i12n_type, i12n))
1163
+ def self.from_hash(init_hash)
1164
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::BlockExpression initializer', _pcore_type.init_hash_type, init_hash))
1165
1165
  end
1166
1166
 
1167
- def self.from_asserted_hash(i12n)
1167
+ def self.from_asserted_hash(init_hash)
1168
1168
  new(
1169
- i12n['locator'],
1170
- i12n['offset'],
1171
- i12n['length'],
1172
- i12n.fetch('statements') { _pcore_type['statements'].value })
1169
+ init_hash['locator'],
1170
+ init_hash['offset'],
1171
+ init_hash['length'],
1172
+ init_hash.fetch('statements') { _pcore_type['statements'].value })
1173
1173
  end
1174
1174
 
1175
1175
  def self.create(locator, offset, length, statements = _pcore_type['statements'].value)
@@ -1230,17 +1230,17 @@ class CaseOption < Expression
1230
1230
  })
1231
1231
  end
1232
1232
 
1233
- def self.from_hash(i12n)
1234
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::CaseOption initializer', _pcore_type.i12n_type, i12n))
1233
+ def self.from_hash(init_hash)
1234
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::CaseOption initializer', _pcore_type.init_hash_type, init_hash))
1235
1235
  end
1236
1236
 
1237
- def self.from_asserted_hash(i12n)
1237
+ def self.from_asserted_hash(init_hash)
1238
1238
  new(
1239
- i12n['locator'],
1240
- i12n['offset'],
1241
- i12n['length'],
1242
- i12n['values'],
1243
- i12n['then_expr'])
1239
+ init_hash['locator'],
1240
+ init_hash['offset'],
1241
+ init_hash['length'],
1242
+ init_hash['values'],
1243
+ init_hash['then_expr'])
1244
1244
  end
1245
1245
 
1246
1246
  def self.create(locator, offset, length, values, then_expr = nil)
@@ -1311,17 +1311,17 @@ class CaseExpression < Expression
1311
1311
  })
1312
1312
  end
1313
1313
 
1314
- def self.from_hash(i12n)
1315
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::CaseExpression initializer', _pcore_type.i12n_type, i12n))
1314
+ def self.from_hash(init_hash)
1315
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::CaseExpression initializer', _pcore_type.init_hash_type, init_hash))
1316
1316
  end
1317
1317
 
1318
- def self.from_asserted_hash(i12n)
1318
+ def self.from_asserted_hash(init_hash)
1319
1319
  new(
1320
- i12n['locator'],
1321
- i12n['offset'],
1322
- i12n['length'],
1323
- i12n['test'],
1324
- i12n.fetch('options') { _pcore_type['options'].value })
1320
+ init_hash['locator'],
1321
+ init_hash['offset'],
1322
+ init_hash['length'],
1323
+ init_hash['test'],
1324
+ init_hash.fetch('options') { _pcore_type['options'].value })
1325
1325
  end
1326
1326
 
1327
1327
  def self.create(locator, offset, length, test, options = _pcore_type['options'].value)
@@ -1391,16 +1391,16 @@ class QueryExpression < Expression
1391
1391
  })
1392
1392
  end
1393
1393
 
1394
- def self.from_hash(i12n)
1395
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::QueryExpression initializer', _pcore_type.i12n_type, i12n))
1394
+ def self.from_hash(init_hash)
1395
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::QueryExpression initializer', _pcore_type.init_hash_type, init_hash))
1396
1396
  end
1397
1397
 
1398
- def self.from_asserted_hash(i12n)
1398
+ def self.from_asserted_hash(init_hash)
1399
1399
  new(
1400
- i12n['locator'],
1401
- i12n['offset'],
1402
- i12n['length'],
1403
- i12n['expr'])
1400
+ init_hash['locator'],
1401
+ init_hash['offset'],
1402
+ init_hash['length'],
1403
+ init_hash['expr'])
1404
1404
  end
1405
1405
 
1406
1406
  def self.create(locator, offset, length, expr = nil)
@@ -1509,18 +1509,18 @@ class AttributeOperation < AbstractAttributeOperation
1509
1509
  })
1510
1510
  end
1511
1511
 
1512
- def self.from_hash(i12n)
1513
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::AttributeOperation initializer', _pcore_type.i12n_type, i12n))
1512
+ def self.from_hash(init_hash)
1513
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::AttributeOperation initializer', _pcore_type.init_hash_type, init_hash))
1514
1514
  end
1515
1515
 
1516
- def self.from_asserted_hash(i12n)
1516
+ def self.from_asserted_hash(init_hash)
1517
1517
  new(
1518
- i12n['locator'],
1519
- i12n['offset'],
1520
- i12n['length'],
1521
- i12n['attribute_name'],
1522
- i12n['operator'],
1523
- i12n['value_expr'])
1518
+ init_hash['locator'],
1519
+ init_hash['offset'],
1520
+ init_hash['length'],
1521
+ init_hash['attribute_name'],
1522
+ init_hash['operator'],
1523
+ init_hash['value_expr'])
1524
1524
  end
1525
1525
 
1526
1526
  def self.create(locator, offset, length, attribute_name, operator, value_expr)
@@ -1587,16 +1587,16 @@ class AttributesOperation < AbstractAttributeOperation
1587
1587
  })
1588
1588
  end
1589
1589
 
1590
- def self.from_hash(i12n)
1591
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::AttributesOperation initializer', _pcore_type.i12n_type, i12n))
1590
+ def self.from_hash(init_hash)
1591
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::AttributesOperation initializer', _pcore_type.init_hash_type, init_hash))
1592
1592
  end
1593
1593
 
1594
- def self.from_asserted_hash(i12n)
1594
+ def self.from_asserted_hash(init_hash)
1595
1595
  new(
1596
- i12n['locator'],
1597
- i12n['offset'],
1598
- i12n['length'],
1599
- i12n['expr'])
1596
+ init_hash['locator'],
1597
+ init_hash['offset'],
1598
+ init_hash['length'],
1599
+ init_hash['expr'])
1600
1600
  end
1601
1601
 
1602
1602
  def self.create(locator, offset, length, expr)
@@ -1658,18 +1658,18 @@ class CollectExpression < Expression
1658
1658
  })
1659
1659
  end
1660
1660
 
1661
- def self.from_hash(i12n)
1662
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::CollectExpression initializer', _pcore_type.i12n_type, i12n))
1661
+ def self.from_hash(init_hash)
1662
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::CollectExpression initializer', _pcore_type.init_hash_type, init_hash))
1663
1663
  end
1664
1664
 
1665
- def self.from_asserted_hash(i12n)
1665
+ def self.from_asserted_hash(init_hash)
1666
1666
  new(
1667
- i12n['locator'],
1668
- i12n['offset'],
1669
- i12n['length'],
1670
- i12n['type_expr'],
1671
- i12n['query'],
1672
- i12n.fetch('operations') { _pcore_type['operations'].value })
1667
+ init_hash['locator'],
1668
+ init_hash['offset'],
1669
+ init_hash['length'],
1670
+ init_hash['type_expr'],
1671
+ init_hash['query'],
1672
+ init_hash.fetch('operations') { _pcore_type['operations'].value })
1673
1673
  end
1674
1674
 
1675
1675
  def self.create(locator, offset, length, type_expr, query, operations = _pcore_type['operations'].value)
@@ -1758,19 +1758,19 @@ class Parameter < Positioned
1758
1758
  })
1759
1759
  end
1760
1760
 
1761
- def self.from_hash(i12n)
1762
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::Parameter initializer', _pcore_type.i12n_type, i12n))
1761
+ def self.from_hash(init_hash)
1762
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::Parameter initializer', _pcore_type.init_hash_type, init_hash))
1763
1763
  end
1764
1764
 
1765
- def self.from_asserted_hash(i12n)
1765
+ def self.from_asserted_hash(init_hash)
1766
1766
  new(
1767
- i12n['locator'],
1768
- i12n['offset'],
1769
- i12n['length'],
1770
- i12n['name'],
1771
- i12n['value'],
1772
- i12n['type_expr'],
1773
- i12n['captures_rest'])
1767
+ init_hash['locator'],
1768
+ init_hash['offset'],
1769
+ init_hash['length'],
1770
+ init_hash['name'],
1771
+ init_hash['value'],
1772
+ init_hash['type_expr'],
1773
+ init_hash['captures_rest'])
1774
1774
  end
1775
1775
 
1776
1776
  def self.create(locator, offset, length, name, value = nil, type_expr = nil, captures_rest = nil)
@@ -1863,18 +1863,18 @@ class NamedDefinition < Definition
1863
1863
  })
1864
1864
  end
1865
1865
 
1866
- def self.from_hash(i12n)
1867
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::NamedDefinition initializer', _pcore_type.i12n_type, i12n))
1866
+ def self.from_hash(init_hash)
1867
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::NamedDefinition initializer', _pcore_type.init_hash_type, init_hash))
1868
1868
  end
1869
1869
 
1870
- def self.from_asserted_hash(i12n)
1870
+ def self.from_asserted_hash(init_hash)
1871
1871
  new(
1872
- i12n['locator'],
1873
- i12n['offset'],
1874
- i12n['length'],
1875
- i12n['name'],
1876
- i12n.fetch('parameters') { _pcore_type['parameters'].value },
1877
- i12n['body'])
1872
+ init_hash['locator'],
1873
+ init_hash['offset'],
1874
+ init_hash['length'],
1875
+ init_hash['name'],
1876
+ init_hash.fetch('parameters') { _pcore_type['parameters'].value },
1877
+ init_hash['body'])
1878
1878
  end
1879
1879
 
1880
1880
  def self.create(locator, offset, length, name, parameters = _pcore_type['parameters'].value, body = nil)
@@ -1949,19 +1949,19 @@ class FunctionDefinition < NamedDefinition
1949
1949
  })
1950
1950
  end
1951
1951
 
1952
- def self.from_hash(i12n)
1953
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::FunctionDefinition initializer', _pcore_type.i12n_type, i12n))
1952
+ def self.from_hash(init_hash)
1953
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::FunctionDefinition initializer', _pcore_type.init_hash_type, init_hash))
1954
1954
  end
1955
1955
 
1956
- def self.from_asserted_hash(i12n)
1956
+ def self.from_asserted_hash(init_hash)
1957
1957
  new(
1958
- i12n['locator'],
1959
- i12n['offset'],
1960
- i12n['length'],
1961
- i12n['name'],
1962
- i12n.fetch('parameters') { _pcore_type['parameters'].value },
1963
- i12n['body'],
1964
- i12n['return_type'])
1958
+ init_hash['locator'],
1959
+ init_hash['offset'],
1960
+ init_hash['length'],
1961
+ init_hash['name'],
1962
+ init_hash.fetch('parameters') { _pcore_type['parameters'].value },
1963
+ init_hash['body'],
1964
+ init_hash['return_type'])
1965
1965
  end
1966
1966
 
1967
1967
  def self.create(locator, offset, length, name, parameters = _pcore_type['parameters'].value, body = nil, return_type = nil)
@@ -2083,16 +2083,16 @@ class QRefDefinition < Definition
2083
2083
  })
2084
2084
  end
2085
2085
 
2086
- def self.from_hash(i12n)
2087
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::QRefDefinition initializer', _pcore_type.i12n_type, i12n))
2086
+ def self.from_hash(init_hash)
2087
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::QRefDefinition initializer', _pcore_type.init_hash_type, init_hash))
2088
2088
  end
2089
2089
 
2090
- def self.from_asserted_hash(i12n)
2090
+ def self.from_asserted_hash(init_hash)
2091
2091
  new(
2092
- i12n['locator'],
2093
- i12n['offset'],
2094
- i12n['length'],
2095
- i12n['name'])
2092
+ init_hash['locator'],
2093
+ init_hash['offset'],
2094
+ init_hash['length'],
2095
+ init_hash['name'])
2096
2096
  end
2097
2097
 
2098
2098
  def self.create(locator, offset, length, name)
@@ -2139,17 +2139,17 @@ class TypeAlias < QRefDefinition
2139
2139
  })
2140
2140
  end
2141
2141
 
2142
- def self.from_hash(i12n)
2143
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::TypeAlias initializer', _pcore_type.i12n_type, i12n))
2142
+ def self.from_hash(init_hash)
2143
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::TypeAlias initializer', _pcore_type.init_hash_type, init_hash))
2144
2144
  end
2145
2145
 
2146
- def self.from_asserted_hash(i12n)
2146
+ def self.from_asserted_hash(init_hash)
2147
2147
  new(
2148
- i12n['locator'],
2149
- i12n['offset'],
2150
- i12n['length'],
2151
- i12n['name'],
2152
- i12n['type_expr'])
2148
+ init_hash['locator'],
2149
+ init_hash['offset'],
2150
+ init_hash['length'],
2151
+ init_hash['name'],
2152
+ init_hash['type_expr'])
2153
2153
  end
2154
2154
 
2155
2155
  def self.create(locator, offset, length, name, type_expr = nil)
@@ -2214,17 +2214,17 @@ class TypeMapping < Definition
2214
2214
  })
2215
2215
  end
2216
2216
 
2217
- def self.from_hash(i12n)
2218
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::TypeMapping initializer', _pcore_type.i12n_type, i12n))
2217
+ def self.from_hash(init_hash)
2218
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::TypeMapping initializer', _pcore_type.init_hash_type, init_hash))
2219
2219
  end
2220
2220
 
2221
- def self.from_asserted_hash(i12n)
2221
+ def self.from_asserted_hash(init_hash)
2222
2222
  new(
2223
- i12n['locator'],
2224
- i12n['offset'],
2225
- i12n['length'],
2226
- i12n['type_expr'],
2227
- i12n['mapping_expr'])
2223
+ init_hash['locator'],
2224
+ init_hash['offset'],
2225
+ init_hash['length'],
2226
+ init_hash['type_expr'],
2227
+ init_hash['mapping_expr'])
2228
2228
  end
2229
2229
 
2230
2230
  def self.create(locator, offset, length, type_expr = nil, mapping_expr = nil)
@@ -2298,18 +2298,18 @@ class TypeDefinition < QRefDefinition
2298
2298
  })
2299
2299
  end
2300
2300
 
2301
- def self.from_hash(i12n)
2302
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::TypeDefinition initializer', _pcore_type.i12n_type, i12n))
2301
+ def self.from_hash(init_hash)
2302
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::TypeDefinition initializer', _pcore_type.init_hash_type, init_hash))
2303
2303
  end
2304
2304
 
2305
- def self.from_asserted_hash(i12n)
2305
+ def self.from_asserted_hash(init_hash)
2306
2306
  new(
2307
- i12n['locator'],
2308
- i12n['offset'],
2309
- i12n['length'],
2310
- i12n['name'],
2311
- i12n['parent'],
2312
- i12n['body'])
2307
+ init_hash['locator'],
2308
+ init_hash['offset'],
2309
+ init_hash['length'],
2310
+ init_hash['name'],
2311
+ init_hash['parent'],
2312
+ init_hash['body'])
2313
2313
  end
2314
2314
 
2315
2315
  def self.create(locator, offset, length, name, parent = nil, body = nil)
@@ -2380,18 +2380,18 @@ class NodeDefinition < Definition
2380
2380
  })
2381
2381
  end
2382
2382
 
2383
- def self.from_hash(i12n)
2384
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::NodeDefinition initializer', _pcore_type.i12n_type, i12n))
2383
+ def self.from_hash(init_hash)
2384
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::NodeDefinition initializer', _pcore_type.init_hash_type, init_hash))
2385
2385
  end
2386
2386
 
2387
- def self.from_asserted_hash(i12n)
2387
+ def self.from_asserted_hash(init_hash)
2388
2388
  new(
2389
- i12n['locator'],
2390
- i12n['offset'],
2391
- i12n['length'],
2392
- i12n['host_matches'],
2393
- i12n['parent'],
2394
- i12n['body'])
2389
+ init_hash['locator'],
2390
+ init_hash['offset'],
2391
+ init_hash['length'],
2392
+ init_hash['host_matches'],
2393
+ init_hash['parent'],
2394
+ init_hash['body'])
2395
2395
  end
2396
2396
 
2397
2397
  def self.create(locator, offset, length, host_matches, parent = nil, body = nil)
@@ -2471,16 +2471,16 @@ class SiteDefinition < Definition
2471
2471
  })
2472
2472
  end
2473
2473
 
2474
- def self.from_hash(i12n)
2475
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::SiteDefinition initializer', _pcore_type.i12n_type, i12n))
2474
+ def self.from_hash(init_hash)
2475
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::SiteDefinition initializer', _pcore_type.init_hash_type, init_hash))
2476
2476
  end
2477
2477
 
2478
- def self.from_asserted_hash(i12n)
2478
+ def self.from_asserted_hash(init_hash)
2479
2479
  new(
2480
- i12n['locator'],
2481
- i12n['offset'],
2482
- i12n['length'],
2483
- i12n['body'])
2480
+ init_hash['locator'],
2481
+ init_hash['offset'],
2482
+ init_hash['length'],
2483
+ init_hash['body'])
2484
2484
  end
2485
2485
 
2486
2486
  def self.create(locator, offset, length, body = nil)
@@ -2549,19 +2549,19 @@ class SubLocatedExpression < Expression
2549
2549
  })
2550
2550
  end
2551
2551
 
2552
- def self.from_hash(i12n)
2553
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::SubLocatedExpression initializer', _pcore_type.i12n_type, i12n))
2552
+ def self.from_hash(init_hash)
2553
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::SubLocatedExpression initializer', _pcore_type.init_hash_type, init_hash))
2554
2554
  end
2555
2555
 
2556
- def self.from_asserted_hash(i12n)
2556
+ def self.from_asserted_hash(init_hash)
2557
2557
  new(
2558
- i12n['locator'],
2559
- i12n['offset'],
2560
- i12n['length'],
2561
- i12n['expr'],
2562
- i12n.fetch('line_offsets') { _pcore_type['line_offsets'].value },
2563
- i12n['leading_line_count'],
2564
- i12n['leading_line_offset'])
2558
+ init_hash['locator'],
2559
+ init_hash['offset'],
2560
+ init_hash['length'],
2561
+ init_hash['expr'],
2562
+ init_hash.fetch('line_offsets') { _pcore_type['line_offsets'].value },
2563
+ init_hash['leading_line_count'],
2564
+ init_hash['leading_line_offset'])
2565
2565
  end
2566
2566
 
2567
2567
  def self.create(locator, offset, length, expr, line_offsets = _pcore_type['line_offsets'].value, leading_line_count = nil, leading_line_offset = nil)
@@ -2637,17 +2637,17 @@ class HeredocExpression < Expression
2637
2637
  })
2638
2638
  end
2639
2639
 
2640
- def self.from_hash(i12n)
2641
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::HeredocExpression initializer', _pcore_type.i12n_type, i12n))
2640
+ def self.from_hash(init_hash)
2641
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::HeredocExpression initializer', _pcore_type.init_hash_type, init_hash))
2642
2642
  end
2643
2643
 
2644
- def self.from_asserted_hash(i12n)
2644
+ def self.from_asserted_hash(init_hash)
2645
2645
  new(
2646
- i12n['locator'],
2647
- i12n['offset'],
2648
- i12n['length'],
2649
- i12n['text_expr'],
2650
- i12n['syntax'])
2646
+ init_hash['locator'],
2647
+ init_hash['offset'],
2648
+ init_hash['length'],
2649
+ init_hash['text_expr'],
2650
+ init_hash['syntax'])
2651
2651
  end
2652
2652
 
2653
2653
  def self.create(locator, offset, length, text_expr, syntax = nil)
@@ -2712,19 +2712,19 @@ class HostClassDefinition < NamedDefinition
2712
2712
  })
2713
2713
  end
2714
2714
 
2715
- def self.from_hash(i12n)
2716
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::HostClassDefinition initializer', _pcore_type.i12n_type, i12n))
2715
+ def self.from_hash(init_hash)
2716
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::HostClassDefinition initializer', _pcore_type.init_hash_type, init_hash))
2717
2717
  end
2718
2718
 
2719
- def self.from_asserted_hash(i12n)
2719
+ def self.from_asserted_hash(init_hash)
2720
2720
  new(
2721
- i12n['locator'],
2722
- i12n['offset'],
2723
- i12n['length'],
2724
- i12n['name'],
2725
- i12n.fetch('parameters') { _pcore_type['parameters'].value },
2726
- i12n['body'],
2727
- i12n['parent_class'])
2721
+ init_hash['locator'],
2722
+ init_hash['offset'],
2723
+ init_hash['length'],
2724
+ init_hash['name'],
2725
+ init_hash.fetch('parameters') { _pcore_type['parameters'].value },
2726
+ init_hash['body'],
2727
+ init_hash['parent_class'])
2728
2728
  end
2729
2729
 
2730
2730
  def self.create(locator, offset, length, name, parameters = _pcore_type['parameters'].value, body = nil, parent_class = nil)
@@ -2800,18 +2800,18 @@ class LambdaExpression < Expression
2800
2800
  })
2801
2801
  end
2802
2802
 
2803
- def self.from_hash(i12n)
2804
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::LambdaExpression initializer', _pcore_type.i12n_type, i12n))
2803
+ def self.from_hash(init_hash)
2804
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::LambdaExpression initializer', _pcore_type.init_hash_type, init_hash))
2805
2805
  end
2806
2806
 
2807
- def self.from_asserted_hash(i12n)
2807
+ def self.from_asserted_hash(init_hash)
2808
2808
  new(
2809
- i12n['locator'],
2810
- i12n['offset'],
2811
- i12n['length'],
2812
- i12n.fetch('parameters') { _pcore_type['parameters'].value },
2813
- i12n['body'],
2814
- i12n['return_type'])
2809
+ init_hash['locator'],
2810
+ init_hash['offset'],
2811
+ init_hash['length'],
2812
+ init_hash.fetch('parameters') { _pcore_type['parameters'].value },
2813
+ init_hash['body'],
2814
+ init_hash['return_type'])
2815
2815
  end
2816
2816
 
2817
2817
  def self.create(locator, offset, length, parameters = _pcore_type['parameters'].value, body = nil, return_type = nil)
@@ -2896,18 +2896,18 @@ class IfExpression < Expression
2896
2896
  })
2897
2897
  end
2898
2898
 
2899
- def self.from_hash(i12n)
2900
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::IfExpression initializer', _pcore_type.i12n_type, i12n))
2899
+ def self.from_hash(init_hash)
2900
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::IfExpression initializer', _pcore_type.init_hash_type, init_hash))
2901
2901
  end
2902
2902
 
2903
- def self.from_asserted_hash(i12n)
2903
+ def self.from_asserted_hash(init_hash)
2904
2904
  new(
2905
- i12n['locator'],
2906
- i12n['offset'],
2907
- i12n['length'],
2908
- i12n['test'],
2909
- i12n['then_expr'],
2910
- i12n['else_expr'])
2905
+ init_hash['locator'],
2906
+ init_hash['offset'],
2907
+ init_hash['length'],
2908
+ init_hash['test'],
2909
+ init_hash['then_expr'],
2910
+ init_hash['else_expr'])
2911
2911
  end
2912
2912
 
2913
2913
  def self.create(locator, offset, length, test, then_expr = nil, else_expr = nil)
@@ -3027,19 +3027,19 @@ class CallExpression < Expression
3027
3027
  })
3028
3028
  end
3029
3029
 
3030
- def self.from_hash(i12n)
3031
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::CallExpression initializer', _pcore_type.i12n_type, i12n))
3030
+ def self.from_hash(init_hash)
3031
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::CallExpression initializer', _pcore_type.init_hash_type, init_hash))
3032
3032
  end
3033
3033
 
3034
- def self.from_asserted_hash(i12n)
3034
+ def self.from_asserted_hash(init_hash)
3035
3035
  new(
3036
- i12n['locator'],
3037
- i12n['offset'],
3038
- i12n['length'],
3039
- i12n['functor_expr'],
3040
- i12n.fetch('rval_required') { false },
3041
- i12n.fetch('arguments') { _pcore_type['arguments'].value },
3042
- i12n['lambda'])
3036
+ init_hash['locator'],
3037
+ init_hash['offset'],
3038
+ init_hash['length'],
3039
+ init_hash['functor_expr'],
3040
+ init_hash.fetch('rval_required') { false },
3041
+ init_hash.fetch('arguments') { _pcore_type['arguments'].value },
3042
+ init_hash['lambda'])
3043
3043
  end
3044
3044
 
3045
3045
  def self.create(locator, offset, length, functor_expr, rval_required = false, arguments = _pcore_type['arguments'].value, lambda = nil)
@@ -3231,17 +3231,17 @@ class LiteralRegularExpression < LiteralValue
3231
3231
  })
3232
3232
  end
3233
3233
 
3234
- def self.from_hash(i12n)
3235
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::LiteralRegularExpression initializer', _pcore_type.i12n_type, i12n))
3234
+ def self.from_hash(init_hash)
3235
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::LiteralRegularExpression initializer', _pcore_type.init_hash_type, init_hash))
3236
3236
  end
3237
3237
 
3238
- def self.from_asserted_hash(i12n)
3238
+ def self.from_asserted_hash(init_hash)
3239
3239
  new(
3240
- i12n['locator'],
3241
- i12n['offset'],
3242
- i12n['length'],
3243
- i12n['value'],
3244
- i12n['pattern'])
3240
+ init_hash['locator'],
3241
+ init_hash['offset'],
3242
+ init_hash['length'],
3243
+ init_hash['value'],
3244
+ init_hash['pattern'])
3245
3245
  end
3246
3246
 
3247
3247
  def self.create(locator, offset, length, value, pattern)
@@ -3290,16 +3290,16 @@ class LiteralString < LiteralValue
3290
3290
  })
3291
3291
  end
3292
3292
 
3293
- def self.from_hash(i12n)
3294
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::LiteralString initializer', _pcore_type.i12n_type, i12n))
3293
+ def self.from_hash(init_hash)
3294
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::LiteralString initializer', _pcore_type.init_hash_type, init_hash))
3295
3295
  end
3296
3296
 
3297
- def self.from_asserted_hash(i12n)
3297
+ def self.from_asserted_hash(init_hash)
3298
3298
  new(
3299
- i12n['locator'],
3300
- i12n['offset'],
3301
- i12n['length'],
3302
- i12n['value'])
3299
+ init_hash['locator'],
3300
+ init_hash['offset'],
3301
+ init_hash['length'],
3302
+ init_hash['value'])
3303
3303
  end
3304
3304
 
3305
3305
  def self.create(locator, offset, length, value)
@@ -3355,17 +3355,17 @@ class LiteralInteger < LiteralNumber
3355
3355
  })
3356
3356
  end
3357
3357
 
3358
- def self.from_hash(i12n)
3359
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::LiteralInteger initializer', _pcore_type.i12n_type, i12n))
3358
+ def self.from_hash(init_hash)
3359
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::LiteralInteger initializer', _pcore_type.init_hash_type, init_hash))
3360
3360
  end
3361
3361
 
3362
- def self.from_asserted_hash(i12n)
3362
+ def self.from_asserted_hash(init_hash)
3363
3363
  new(
3364
- i12n['locator'],
3365
- i12n['offset'],
3366
- i12n['length'],
3367
- i12n['value'],
3368
- i12n.fetch('radix') { 10 })
3364
+ init_hash['locator'],
3365
+ init_hash['offset'],
3366
+ init_hash['length'],
3367
+ init_hash['value'],
3368
+ init_hash.fetch('radix') { 10 })
3369
3369
  end
3370
3370
 
3371
3371
  def self.create(locator, offset, length, value, radix = 10)
@@ -3414,16 +3414,16 @@ class LiteralFloat < LiteralNumber
3414
3414
  })
3415
3415
  end
3416
3416
 
3417
- def self.from_hash(i12n)
3418
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::LiteralFloat initializer', _pcore_type.i12n_type, i12n))
3417
+ def self.from_hash(init_hash)
3418
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::LiteralFloat initializer', _pcore_type.init_hash_type, init_hash))
3419
3419
  end
3420
3420
 
3421
- def self.from_asserted_hash(i12n)
3421
+ def self.from_asserted_hash(init_hash)
3422
3422
  new(
3423
- i12n['locator'],
3424
- i12n['offset'],
3425
- i12n['length'],
3426
- i12n['value'])
3423
+ init_hash['locator'],
3424
+ init_hash['offset'],
3425
+ init_hash['length'],
3426
+ init_hash['value'])
3427
3427
  end
3428
3428
 
3429
3429
  def self.create(locator, offset, length, value)
@@ -3483,16 +3483,16 @@ class LiteralBoolean < LiteralValue
3483
3483
  })
3484
3484
  end
3485
3485
 
3486
- def self.from_hash(i12n)
3487
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::LiteralBoolean initializer', _pcore_type.i12n_type, i12n))
3486
+ def self.from_hash(init_hash)
3487
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::LiteralBoolean initializer', _pcore_type.init_hash_type, init_hash))
3488
3488
  end
3489
3489
 
3490
- def self.from_asserted_hash(i12n)
3490
+ def self.from_asserted_hash(init_hash)
3491
3491
  new(
3492
- i12n['locator'],
3493
- i12n['offset'],
3494
- i12n['length'],
3495
- i12n['value'])
3492
+ init_hash['locator'],
3493
+ init_hash['offset'],
3494
+ init_hash['length'],
3495
+ init_hash['value'])
3496
3496
  end
3497
3497
 
3498
3498
  def self.create(locator, offset, length, value)
@@ -3560,16 +3560,16 @@ class ConcatenatedString < Expression
3560
3560
  })
3561
3561
  end
3562
3562
 
3563
- def self.from_hash(i12n)
3564
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::ConcatenatedString initializer', _pcore_type.i12n_type, i12n))
3563
+ def self.from_hash(init_hash)
3564
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::ConcatenatedString initializer', _pcore_type.init_hash_type, init_hash))
3565
3565
  end
3566
3566
 
3567
- def self.from_asserted_hash(i12n)
3567
+ def self.from_asserted_hash(init_hash)
3568
3568
  new(
3569
- i12n['locator'],
3570
- i12n['offset'],
3571
- i12n['length'],
3572
- i12n.fetch('segments') { _pcore_type['segments'].value })
3569
+ init_hash['locator'],
3570
+ init_hash['offset'],
3571
+ init_hash['length'],
3572
+ init_hash.fetch('segments') { _pcore_type['segments'].value })
3573
3573
  end
3574
3574
 
3575
3575
  def self.create(locator, offset, length, segments = _pcore_type['segments'].value)
@@ -3626,16 +3626,16 @@ class QualifiedName < LiteralValue
3626
3626
  })
3627
3627
  end
3628
3628
 
3629
- def self.from_hash(i12n)
3630
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::QualifiedName initializer', _pcore_type.i12n_type, i12n))
3629
+ def self.from_hash(init_hash)
3630
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::QualifiedName initializer', _pcore_type.init_hash_type, init_hash))
3631
3631
  end
3632
3632
 
3633
- def self.from_asserted_hash(i12n)
3633
+ def self.from_asserted_hash(init_hash)
3634
3634
  new(
3635
- i12n['locator'],
3636
- i12n['offset'],
3637
- i12n['length'],
3638
- i12n['value'])
3635
+ init_hash['locator'],
3636
+ init_hash['offset'],
3637
+ init_hash['length'],
3638
+ init_hash['value'])
3639
3639
  end
3640
3640
 
3641
3641
  def self.create(locator, offset, length, value)
@@ -3683,17 +3683,17 @@ class ReservedWord < LiteralValue
3683
3683
  })
3684
3684
  end
3685
3685
 
3686
- def self.from_hash(i12n)
3687
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::ReservedWord initializer', _pcore_type.i12n_type, i12n))
3686
+ def self.from_hash(init_hash)
3687
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::ReservedWord initializer', _pcore_type.init_hash_type, init_hash))
3688
3688
  end
3689
3689
 
3690
- def self.from_asserted_hash(i12n)
3690
+ def self.from_asserted_hash(init_hash)
3691
3691
  new(
3692
- i12n['locator'],
3693
- i12n['offset'],
3694
- i12n['length'],
3695
- i12n['word'],
3696
- i12n['future'])
3692
+ init_hash['locator'],
3693
+ init_hash['offset'],
3694
+ init_hash['length'],
3695
+ init_hash['word'],
3696
+ init_hash['future'])
3697
3697
  end
3698
3698
 
3699
3699
  def self.create(locator, offset, length, word, future = nil)
@@ -3746,16 +3746,16 @@ class QualifiedReference < LiteralValue
3746
3746
  })
3747
3747
  end
3748
3748
 
3749
- def self.from_hash(i12n)
3750
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::QualifiedReference initializer', _pcore_type.i12n_type, i12n))
3749
+ def self.from_hash(init_hash)
3750
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::QualifiedReference initializer', _pcore_type.init_hash_type, init_hash))
3751
3751
  end
3752
3752
 
3753
- def self.from_asserted_hash(i12n)
3753
+ def self.from_asserted_hash(init_hash)
3754
3754
  new(
3755
- i12n['locator'],
3756
- i12n['offset'],
3757
- i12n['length'],
3758
- i12n['cased_value'])
3755
+ init_hash['locator'],
3756
+ init_hash['offset'],
3757
+ init_hash['length'],
3758
+ init_hash['cased_value'])
3759
3759
  end
3760
3760
 
3761
3761
  def self.create(locator, offset, length, cased_value)
@@ -3831,17 +3831,17 @@ class EppExpression < Expression
3831
3831
  })
3832
3832
  end
3833
3833
 
3834
- def self.from_hash(i12n)
3835
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::EppExpression initializer', _pcore_type.i12n_type, i12n))
3834
+ def self.from_hash(init_hash)
3835
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::EppExpression initializer', _pcore_type.init_hash_type, init_hash))
3836
3836
  end
3837
3837
 
3838
- def self.from_asserted_hash(i12n)
3838
+ def self.from_asserted_hash(init_hash)
3839
3839
  new(
3840
- i12n['locator'],
3841
- i12n['offset'],
3842
- i12n['length'],
3843
- i12n['parameters_specified'],
3844
- i12n['body'])
3840
+ init_hash['locator'],
3841
+ init_hash['offset'],
3842
+ init_hash['length'],
3843
+ init_hash['parameters_specified'],
3844
+ init_hash['body'])
3845
3845
  end
3846
3846
 
3847
3847
  def self.create(locator, offset, length, parameters_specified = nil, body = nil)
@@ -3939,17 +3939,17 @@ class ResourceBody < Positioned
3939
3939
  })
3940
3940
  end
3941
3941
 
3942
- def self.from_hash(i12n)
3943
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::ResourceBody initializer', _pcore_type.i12n_type, i12n))
3942
+ def self.from_hash(init_hash)
3943
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::ResourceBody initializer', _pcore_type.init_hash_type, init_hash))
3944
3944
  end
3945
3945
 
3946
- def self.from_asserted_hash(i12n)
3946
+ def self.from_asserted_hash(init_hash)
3947
3947
  new(
3948
- i12n['locator'],
3949
- i12n['offset'],
3950
- i12n['length'],
3951
- i12n['title'],
3952
- i12n.fetch('operations') { _pcore_type['operations'].value })
3948
+ init_hash['locator'],
3949
+ init_hash['offset'],
3950
+ init_hash['length'],
3951
+ init_hash['title'],
3952
+ init_hash.fetch('operations') { _pcore_type['operations'].value })
3953
3953
  end
3954
3954
 
3955
3955
  def self.create(locator, offset, length, title = nil, operations = _pcore_type['operations'].value)
@@ -4027,16 +4027,16 @@ class AbstractResource < Expression
4027
4027
  })
4028
4028
  end
4029
4029
 
4030
- def self.from_hash(i12n)
4031
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::AbstractResource initializer', _pcore_type.i12n_type, i12n))
4030
+ def self.from_hash(init_hash)
4031
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::AbstractResource initializer', _pcore_type.init_hash_type, init_hash))
4032
4032
  end
4033
4033
 
4034
- def self.from_asserted_hash(i12n)
4034
+ def self.from_asserted_hash(init_hash)
4035
4035
  new(
4036
- i12n['locator'],
4037
- i12n['offset'],
4038
- i12n['length'],
4039
- i12n.fetch('form') { "regular" })
4036
+ init_hash['locator'],
4037
+ init_hash['offset'],
4038
+ init_hash['length'],
4039
+ init_hash.fetch('form') { "regular" })
4040
4040
  end
4041
4041
 
4042
4042
  def self.create(locator, offset, length, form = "regular")
@@ -4092,18 +4092,18 @@ class ResourceExpression < AbstractResource
4092
4092
  })
4093
4093
  end
4094
4094
 
4095
- def self.from_hash(i12n)
4096
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::ResourceExpression initializer', _pcore_type.i12n_type, i12n))
4095
+ def self.from_hash(init_hash)
4096
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::ResourceExpression initializer', _pcore_type.init_hash_type, init_hash))
4097
4097
  end
4098
4098
 
4099
- def self.from_asserted_hash(i12n)
4099
+ def self.from_asserted_hash(init_hash)
4100
4100
  new(
4101
- i12n['locator'],
4102
- i12n['offset'],
4103
- i12n['length'],
4104
- i12n['type_name'],
4105
- i12n.fetch('form') { "regular" },
4106
- i12n.fetch('bodies') { _pcore_type['bodies'].value })
4101
+ init_hash['locator'],
4102
+ init_hash['offset'],
4103
+ init_hash['length'],
4104
+ init_hash['type_name'],
4105
+ init_hash.fetch('form') { "regular" },
4106
+ init_hash.fetch('bodies') { _pcore_type['bodies'].value })
4107
4107
  end
4108
4108
 
4109
4109
  def self.create(locator, offset, length, type_name, form = "regular", bodies = _pcore_type['bodies'].value)
@@ -4177,19 +4177,19 @@ class CapabilityMapping < Definition
4177
4177
  })
4178
4178
  end
4179
4179
 
4180
- def self.from_hash(i12n)
4181
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::CapabilityMapping initializer', _pcore_type.i12n_type, i12n))
4180
+ def self.from_hash(init_hash)
4181
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::CapabilityMapping initializer', _pcore_type.init_hash_type, init_hash))
4182
4182
  end
4183
4183
 
4184
- def self.from_asserted_hash(i12n)
4184
+ def self.from_asserted_hash(init_hash)
4185
4185
  new(
4186
- i12n['locator'],
4187
- i12n['offset'],
4188
- i12n['length'],
4189
- i12n['kind'],
4190
- i12n['capability'],
4191
- i12n['component'],
4192
- i12n.fetch('mappings') { _pcore_type['mappings'].value })
4186
+ init_hash['locator'],
4187
+ init_hash['offset'],
4188
+ init_hash['length'],
4189
+ init_hash['kind'],
4190
+ init_hash['capability'],
4191
+ init_hash['component'],
4192
+ init_hash.fetch('mappings') { _pcore_type['mappings'].value })
4193
4193
  end
4194
4194
 
4195
4195
  def self.create(locator, offset, length, kind, capability, component, mappings = _pcore_type['mappings'].value)
@@ -4273,18 +4273,18 @@ class ResourceDefaultsExpression < AbstractResource
4273
4273
  })
4274
4274
  end
4275
4275
 
4276
- def self.from_hash(i12n)
4277
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::ResourceDefaultsExpression initializer', _pcore_type.i12n_type, i12n))
4276
+ def self.from_hash(init_hash)
4277
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::ResourceDefaultsExpression initializer', _pcore_type.init_hash_type, init_hash))
4278
4278
  end
4279
4279
 
4280
- def self.from_asserted_hash(i12n)
4280
+ def self.from_asserted_hash(init_hash)
4281
4281
  new(
4282
- i12n['locator'],
4283
- i12n['offset'],
4284
- i12n['length'],
4285
- i12n.fetch('form') { "regular" },
4286
- i12n['type_ref'],
4287
- i12n.fetch('operations') { _pcore_type['operations'].value })
4282
+ init_hash['locator'],
4283
+ init_hash['offset'],
4284
+ init_hash['length'],
4285
+ init_hash.fetch('form') { "regular" },
4286
+ init_hash['type_ref'],
4287
+ init_hash.fetch('operations') { _pcore_type['operations'].value })
4288
4288
  end
4289
4289
 
4290
4290
  def self.create(locator, offset, length, form = "regular", type_ref = nil, operations = _pcore_type['operations'].value)
@@ -4356,18 +4356,18 @@ class ResourceOverrideExpression < AbstractResource
4356
4356
  })
4357
4357
  end
4358
4358
 
4359
- def self.from_hash(i12n)
4360
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::ResourceOverrideExpression initializer', _pcore_type.i12n_type, i12n))
4359
+ def self.from_hash(init_hash)
4360
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::ResourceOverrideExpression initializer', _pcore_type.init_hash_type, init_hash))
4361
4361
  end
4362
4362
 
4363
- def self.from_asserted_hash(i12n)
4363
+ def self.from_asserted_hash(init_hash)
4364
4364
  new(
4365
- i12n['locator'],
4366
- i12n['offset'],
4367
- i12n['length'],
4368
- i12n['resources'],
4369
- i12n.fetch('form') { "regular" },
4370
- i12n.fetch('operations') { _pcore_type['operations'].value })
4365
+ init_hash['locator'],
4366
+ init_hash['offset'],
4367
+ init_hash['length'],
4368
+ init_hash['resources'],
4369
+ init_hash.fetch('form') { "regular" },
4370
+ init_hash.fetch('operations') { _pcore_type['operations'].value })
4371
4371
  end
4372
4372
 
4373
4373
  def self.create(locator, offset, length, resources, form = "regular", operations = _pcore_type['operations'].value)
@@ -4436,17 +4436,17 @@ class SelectorEntry < Positioned
4436
4436
  })
4437
4437
  end
4438
4438
 
4439
- def self.from_hash(i12n)
4440
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::SelectorEntry initializer', _pcore_type.i12n_type, i12n))
4439
+ def self.from_hash(init_hash)
4440
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::SelectorEntry initializer', _pcore_type.init_hash_type, init_hash))
4441
4441
  end
4442
4442
 
4443
- def self.from_asserted_hash(i12n)
4443
+ def self.from_asserted_hash(init_hash)
4444
4444
  new(
4445
- i12n['locator'],
4446
- i12n['offset'],
4447
- i12n['length'],
4448
- i12n['matching_expr'],
4449
- i12n['value_expr'])
4445
+ init_hash['locator'],
4446
+ init_hash['offset'],
4447
+ init_hash['length'],
4448
+ init_hash['matching_expr'],
4449
+ init_hash['value_expr'])
4450
4450
  end
4451
4451
 
4452
4452
  def self.create(locator, offset, length, matching_expr, value_expr)
@@ -4517,17 +4517,17 @@ class SelectorExpression < Expression
4517
4517
  })
4518
4518
  end
4519
4519
 
4520
- def self.from_hash(i12n)
4521
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::SelectorExpression initializer', _pcore_type.i12n_type, i12n))
4520
+ def self.from_hash(init_hash)
4521
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::SelectorExpression initializer', _pcore_type.init_hash_type, init_hash))
4522
4522
  end
4523
4523
 
4524
- def self.from_asserted_hash(i12n)
4524
+ def self.from_asserted_hash(init_hash)
4525
4525
  new(
4526
- i12n['locator'],
4527
- i12n['offset'],
4528
- i12n['length'],
4529
- i12n['left_expr'],
4530
- i12n.fetch('selectors') { _pcore_type['selectors'].value })
4526
+ init_hash['locator'],
4527
+ init_hash['offset'],
4528
+ init_hash['length'],
4529
+ init_hash['left_expr'],
4530
+ init_hash.fetch('selectors') { _pcore_type['selectors'].value })
4531
4531
  end
4532
4532
 
4533
4533
  def self.create(locator, offset, length, left_expr, selectors = _pcore_type['selectors'].value)
@@ -4641,15 +4641,15 @@ class Program < PopsObject
4641
4641
  })
4642
4642
  end
4643
4643
 
4644
- def self.from_hash(i12n)
4645
- from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::Program initializer', _pcore_type.i12n_type, i12n))
4644
+ def self.from_hash(init_hash)
4645
+ from_asserted_hash(Types::TypeAsserter.assert_instance_of('Puppet::AST::Program initializer', _pcore_type.init_hash_type, init_hash))
4646
4646
  end
4647
4647
 
4648
- def self.from_asserted_hash(i12n)
4648
+ def self.from_asserted_hash(init_hash)
4649
4649
  new(
4650
- i12n['locator'],
4651
- i12n['body'],
4652
- i12n.fetch('definitions') { _pcore_type['definitions'].value })
4650
+ init_hash['locator'],
4651
+ init_hash['body'],
4652
+ init_hash.fetch('definitions') { _pcore_type['definitions'].value })
4653
4653
  end
4654
4654
 
4655
4655
  def self.create(locator, body = nil, definitions = _pcore_type['definitions'].value)
@@ -4665,6 +4665,10 @@ class Program < PopsObject
4665
4665
  attr_reader :definitions
4666
4666
  attr_reader :locator
4667
4667
 
4668
+ def current
4669
+ self
4670
+ end
4671
+
4668
4672
  def source_text
4669
4673
  @locator.string
4670
4674
  end