Class: Puppet::Pops::Model::Factory

Inherits:
Object
  • Object
show all
Defined in:
lib/puppet/pops/model/factory.rb

Defined Under Namespace

Classes: ArgsToNonCallError

Constant Summary collapse

KEY_LENGTH =

Shared build_visitor, since there are many instances of Factory being used

'length'
KEY_OFFSET = 
'offset'
KEY_LOCATOR = 
'locator'
KEY_OPERATOR = 
'operator'
KEY_VALUE = 
'value'
KEY_KEYS = 
'keys'
KEY_NAME = 
'name'
KEY_BODY = 
'body'
KEY_EXPR = 
'expr'
KEY_LEFT_EXPR = 
'left_expr'
KEY_RIGHT_EXPR = 
'right_expr'
KEY_PARAMETERS = 
'parameters'
BUILD_VISITOR = 
Visitor.new(self, 'build')
INFER_VISITOR = 
Visitor.new(self, 'infer')
INTERPOLATION_VISITOR = 
Visitor.new(self, 'interpolate')
MAPOFFSET_VISITOR = 
Visitor.new(self, 'map_offset')
STATEMENT_CALLS = 
{
  'require' => true,
  'realize' => true,
  'include' => true,
  'contain' => true,
  'tag' => true,

  'debug' => true,
  'info' => true,
  'notice' => true,
  'warning' => true,
  'err' => true,

  'fail' => true,
  'import' => true, # discontinued, but transform it to make it call error reporting function
  'break' => true,
  'next' => true,
  'return' => true
}.freeze

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(o, *args) ⇒ Factory

Initialize a factory with a single object, or a class with arguments applied to build of created instance



85
86
87
88
89
90
91
92
93
 
# File 'lib/puppet/pops/model/factory.rb', line 85

def initialize(o, *args)
  @init_hash = {}
  if o.instance_of?(Class)
    @model_class = o
    BUILD_VISITOR.visit_this_class(self, o, args)
  else
    INFER_VISITOR.visit_this(self, o, EMPTY_ARRAY)
  end
end

Instance Attribute Details

#model_class ⇒ Object (readonly) 



43
44
45
 
# File 'lib/puppet/pops/model/factory.rb', line 43

def model_class
  @model_class
end

#unfolded ⇒ Object (readonly) 



43
44
45
 
# File 'lib/puppet/pops/model/factory.rb', line 43

def unfolded
  @unfolded
end

Class Method Details

.APPLY(arguments, body) ⇒ Object 



938
939
940
 
# File 'lib/puppet/pops/model/factory.rb', line 938

def self.APPLY(arguments, body)
  new(ApplyExpression, arguments, body)
end

.APPLY_BLOCK(statements) ⇒ Object 



942
943
944
 
# File 'lib/puppet/pops/model/factory.rb', line 942

def self.APPLY_BLOCK(statements)
  new(ApplyBlockExpression, statements)
end

.ARGUMENTS(args, arg) ⇒ Object 



847
848
849
850
851
852
853
854
855
856
 
# File 'lib/puppet/pops/model/factory.rb', line 847

def self.ARGUMENTS(args, arg)
  if !args.empty? && arg.model_class <= LiteralHash && arg.unfolded
    last = args[args.size() - 1]
    if last.model_class <= LiteralHash && last.unfolded
      last['entries'].concat(arg['entries'])
      return args
    end
  end
  args.push(arg)
end

.ATTRIBUTE_OP(name, op, expr) ⇒ Object 



858
859
860
 
# File 'lib/puppet/pops/model/factory.rb', line 858

def self.ATTRIBUTE_OP(name, op, expr)
  new(AttributeOperation, name, op, expr)
end

.ATTRIBUTES_OP(expr) ⇒ Object 



862
863
864
 
# File 'lib/puppet/pops/model/factory.rb', line 862

def self.ATTRIBUTES_OP(expr)
  new(AttributesOperation, expr)
end

.block(*args) ⇒ Object 



696
 
# File 'lib/puppet/pops/model/factory.rb', line 696

def self.block(*args);                 new(BlockExpression, args.map { |arg| infer(arg) }); end

.block_or_expression(args, left_brace = nil, right_brace = nil) ⇒ Object

Builds a BlockExpression if args size > 1, else the single expression/value in args



908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
 
# File 'lib/puppet/pops/model/factory.rb', line 908

def self.block_or_expression(args, left_brace = nil, right_brace = nil)
  if args.size > 1
    block_expr = new(BlockExpression, args)

    # If given a left and right brace position, use those
    # otherwise use the first and last element of the block
    if !left_brace.nil? && !right_brace.nil?
      block_expr.record_position(args.first[KEY_LOCATOR], left_brace, right_brace)
    else
      block_expr.record_position(args.first[KEY_LOCATOR], args.first, args.last)
    end

    block_expr
  else
    args[0]
  end
end

.CALL_METHOD(functor, argument_list) ⇒ Object 



875
876
877
 
# File 'lib/puppet/pops/model/factory.rb', line 875

def self.CALL_METHOD(functor, argument_list)
  new(CallMethodExpression, functor, true, nil, argument_list)
end

.CALL_NAMED(name, rval_required, argument_list) ⇒ Object 



871
872
873
 
# File 'lib/puppet/pops/model/factory.rb', line 871

def self.CALL_NAMED(name, rval_required, argument_list)
  new(CallNamedFunctionExpression, name, rval_required, argument_list)
end

.call_named(name, rval_required, *argument_list) ⇒ Object

Same as CALL_NAMED but with inference and varargs (for testing purposes)



867
868
869
 
# File 'lib/puppet/pops/model/factory.rb', line 867

def self.call_named(name, rval_required, *argument_list)
  new(CallNamedFunctionExpression, fqn(name), rval_required, argument_list.map { |arg| infer(arg) })
end

.CASE(test_e, *options) ⇒ Object 



706
 
# File 'lib/puppet/pops/model/factory.rb', line 706

def self.CASE(test_e, *options); new(CaseExpression, test_e, options); end

.COLLECT(type_expr, query_expr, attribute_operations) ⇒ Object 



879
880
881
 
# File 'lib/puppet/pops/model/factory.rb', line 879

def self.COLLECT(type_expr, query_expr, attribute_operations)
  new(CollectExpression, type_expr, query_expr, attribute_operations)
end

.concat(*args) ⇒ Object 



1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
 
# File 'lib/puppet/pops/model/factory.rb', line 1116

def self.concat(*args)
  result = ''.dup
  args.each do |e|
    if e.instance_of?(Factory) && e.model_class <= LiteralString
      result << e[KEY_VALUE]
    elsif e.is_a?(String)
      result << e
    else
      raise ArgumentError, _("can only concatenate strings, got %{class_name}") % { class_name: e.class }
    end
  end
  infer(result)
end

.DEFINITION(name, parameters, body) ⇒ Object 



930
931
932
 
# File 'lib/puppet/pops/model/factory.rb', line 930

def self.DEFINITION(name, parameters, body)
  new(ResourceTypeDefinition, name, parameters, body)
end

.EPP(parameters, body) ⇒ Object 



780
781
782
783
784
785
786
787
788
789
 
# File 'lib/puppet/pops/model/factory.rb', line 780

def self.EPP(parameters, body)
  if parameters.nil?
    params = []
    parameters_specified = false
  else
    params = parameters
    parameters_specified = true
  end
  LAMBDA(params, new(EppExpression, parameters_specified, body), nil)
end

.EXPORTED_QUERY(query_expr) ⇒ Object 



843
844
845
 
# File 'lib/puppet/pops/model/factory.rb', line 843

def self.EXPORTED_QUERY(query_expr)
  new(ExportedQuery, query_expr)
end

.fqn(o) ⇒ Object

Creates a QualifiedName representation of o, unless o already represents a QualifiedName in which case it is returned.



743
744
745
 
# File 'lib/puppet/pops/model/factory.rb', line 743

def self.fqn(o)
  o.instance_of?(Factory) && o.model_class <= QualifiedName ? self : new(QualifiedName, o)
end

.fqr(o) ⇒ Object

Creates a QualifiedName representation of o, unless o already represents a QualifiedName in which case it is returned.



750
751
752
 
# File 'lib/puppet/pops/model/factory.rb', line 750

def self.fqr(o)
  o.instance_of?(Factory) && o.model_class <= QualifiedReference ? self : new(QualifiedReference, o)
end

.FUNCTION(name, parameters, body, return_type) ⇒ Object 



946
947
948
 
# File 'lib/puppet/pops/model/factory.rb', line 946

def self.FUNCTION(name, parameters, body, return_type)
  new(FunctionDefinition, name, parameters, body, return_type)
end

.HASH(entries) ⇒ Object 



714
 
# File 'lib/puppet/pops/model/factory.rb', line 714

def self.HASH(entries);                new(LiteralHash, entries, false);               end

.HASH_UNFOLDED(entries) ⇒ Object 



716
 
# File 'lib/puppet/pops/model/factory.rb', line 716

def self.HASH_UNFOLDED(entries);       new(LiteralHash, entries, true);                end

.HEREDOC(name, expr) ⇒ Object 



718
 
# File 'lib/puppet/pops/model/factory.rb', line 718

def self.HEREDOC(name, expr);          new(HeredocExpression, name, expr);             end

.HOSTCLASS(name, parameters, parent, body) ⇒ Object 



926
927
928
 
# File 'lib/puppet/pops/model/factory.rb', line 926

def self.HOSTCLASS(name, parameters, parent, body)
  new(HostClassDefinition, name, parameters, parent, body)
end

.IF(test_e, then_e, else_e) ⇒ Object 



702
 
# File 'lib/puppet/pops/model/factory.rb', line 702

def self.IF(test_e, then_e, else_e);     new(IfExpression, test_e, then_e, else_e);      end

.infer(o) ⇒ Object 



35
36
37
38
39
40
41
 
# File 'lib/puppet/pops/model/factory.rb', line 35

def self.infer(o)
  if o.instance_of?(Factory)
    o
  else
    new(o)
  end
end

.KEY_ENTRY(key, val) ⇒ Object 



712
 
# File 'lib/puppet/pops/model/factory.rb', line 712

def self.KEY_ENTRY(key, val);          new(KeyedEntry, key, val);                      end

.LAMBDA(parameters, body, return_type) ⇒ Object 



950
951
952
 
# File 'lib/puppet/pops/model/factory.rb', line 950

def self.LAMBDA(parameters, body, return_type)
  new(LambdaExpression, parameters, body, return_type)
end

.LIST(entries) ⇒ Object 



722
 
# File 'lib/puppet/pops/model/factory.rb', line 722

def self.LIST(entries);                new(LiteralList, entries);                      end

.literal(o) ⇒ Object

Factory starting points



688
 
# File 'lib/puppet/pops/model/factory.rb', line 688

def self.literal(o);                   infer(o);                                       end

.MAP(match, value) ⇒ Object 



710
 
# File 'lib/puppet/pops/model/factory.rb', line 710

def self.MAP(match, value);            new(SelectorEntry, match, value);               end

.minus(o) ⇒ Object 



690
 
# File 'lib/puppet/pops/model/factory.rb', line 690

def self.minus(o);                     infer(o).minus;                                 end

.name_is_statement?(name) ⇒ Boolean

Returns true if the given name is a “statement keyword” (require, include, contain, error, notice, info, debug

Returns:

  • (Boolean) 


993
994
995
 
# File 'lib/puppet/pops/model/factory.rb', line 993

def self.name_is_statement?(name)
  STATEMENT_CALLS.include?(name)
end

.NAMED_ACCESS(type_name, bodies) ⇒ Object 



883
884
885
 
# File 'lib/puppet/pops/model/factory.rb', line 883

def self.NAMED_ACCESS(type_name, bodies)
  new(NamedAccessExpression, type_name, bodies)
end

.NODE(hosts, parent, body) ⇒ Object 



726
 
# File 'lib/puppet/pops/model/factory.rb', line 726

def self.NODE(hosts, parent, body); new(NodeDefinition, hosts, parent, body); end

.nop?(o) ⇒ Boolean

Returns:

  • (Boolean) 


966
967
968
 
# File 'lib/puppet/pops/model/factory.rb', line 966

def self.nop? o
  o.nil? || o.instance_of?(Factory) && o.model_class <= Nop
end

.NUMBER(name_or_numeric) ⇒ Object 



802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
 
# File 'lib/puppet/pops/model/factory.rb', line 802

def self.NUMBER(name_or_numeric)
  n_radix = Utils.to_n_with_radix(name_or_numeric)
  if n_radix
    val, radix = n_radix
    if val.is_a?(Float)
      new(LiteralFloat, val)
    else
      new(LiteralInteger, val, radix)
    end
  else
    # Bad number should already have been caught by lexer - this should never happen
    # TRANSLATORS 'NUMBER' refers to a method name and the 'name_or_numeric' was the passed in value and should not be translated
    raise ArgumentError, _("Internal Error, NUMBER token does not contain a valid number, %{name_or_numeric}") %
                         { name_or_numeric: name_or_numeric }
  end
end

.PARAM(name, expr = nil) ⇒ Object 



724
 
# File 'lib/puppet/pops/model/factory.rb', line 724

def self.PARAM(name, expr = nil); new(Parameter, name, expr); end

.PLAN(name, parameters, body) ⇒ Object 



934
935
936
 
# File 'lib/puppet/pops/model/factory.rb', line 934

def self.PLAN(name, parameters, body)
  new(PlanDefinition, name, parameters, body, nil)
end

.PROGRAM(body, definitions, locator) ⇒ Object 



903
904
905
 
# File 'lib/puppet/pops/model/factory.rb', line 903

def self.PROGRAM(body, definitions, locator)
  new(Program, body, definitions, locator)
end

.QNAME(name) ⇒ Object

TODO: This is the same a fqn factory method, don’t know if callers to fqn and QNAME can live with the same result or not yet - refactor into one method when decided.



798
799
800
 
# File 'lib/puppet/pops/model/factory.rb', line 798

def self.QNAME(name)
  new(QualifiedName, name)
end

.QNAME_OR_NUMBER(name) ⇒ Object

Convert input string to either a qualified name, a LiteralInteger with radix, or a LiteralFloat



821
822
823
824
825
826
827
828
829
830
831
832
833
 
# File 'lib/puppet/pops/model/factory.rb', line 821

def self.QNAME_OR_NUMBER(name)
  n_radix = Utils.to_n_with_radix(name)
  if n_radix
    val, radix = n_radix
    if val.is_a?(Float)
      new(LiteralFloat, val)
    else
      new(LiteralInteger, val, radix)
    end
  else
    new(QualifiedName, name)
  end
end

.QREF(name) ⇒ Object 



835
836
837
 
# File 'lib/puppet/pops/model/factory.rb', line 835

def self.QREF(name)
  new(QualifiedReference, name)
end

.RENDER_EXPR(expr) ⇒ Object 



776
777
778
 
# File 'lib/puppet/pops/model/factory.rb', line 776

def self.RENDER_EXPR(expr)
  new(RenderExpression, expr)
end

.RENDER_STRING(o) ⇒ Object

TODO_EPP



772
773
774
 
# File 'lib/puppet/pops/model/factory.rb', line 772

def self.RENDER_STRING(o)
  new(RenderStringExpression, o)
end

.RESERVED(name, future = false) ⇒ Object 



791
792
793
 
# File 'lib/puppet/pops/model/factory.rb', line 791

def self.RESERVED(name, future = false)
  new(ReservedWord, name, future)
end

.RESOURCE(type_name, bodies) ⇒ Object 



887
888
889
 
# File 'lib/puppet/pops/model/factory.rb', line 887

def self.RESOURCE(type_name, bodies)
  new(ResourceExpression, type_name, bodies)
end

.RESOURCE_BODY(resource_title, attribute_operations) ⇒ Object 



899
900
901
 
# File 'lib/puppet/pops/model/factory.rb', line 899

def self.RESOURCE_BODY(resource_title, attribute_operations)
  new(ResourceBody, resource_title, attribute_operations)
end

.RESOURCE_DEFAULTS(type_name, attribute_operations) ⇒ Object 



891
892
893
 
# File 'lib/puppet/pops/model/factory.rb', line 891

def self.RESOURCE_DEFAULTS(type_name, attribute_operations)
  new(ResourceDefaultsExpression, type_name, attribute_operations)
end

.RESOURCE_OVERRIDE(resource_ref, attribute_operations) ⇒ Object 



895
896
897
 
# File 'lib/puppet/pops/model/factory.rb', line 895

def self.RESOURCE_OVERRIDE(resource_ref, attribute_operations)
  new(ResourceOverrideExpression, resource_ref, attribute_operations)
end

.resource_shape(expr) ⇒ Object

Returns symbolic information about an expected shape of a resource expression given the LHS of a resource expr.

  • ‘name { }` => `:resource`, create a resource of the given type

  • ‘Name { }` => ’:defaults`, set defaults for the referenced type

  • ‘Name[] { }` => `:override`, overrides instances referenced by LHS

  • _any other_ => ‘:error’, all other are considered illegal



661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
 
# File 'lib/puppet/pops/model/factory.rb', line 661

def self.resource_shape(expr)
  if expr == 'class'
    :class
  elsif expr.instance_of?(self)
    mc = expr.model_class
    if mc <= QualifiedName
      :resource
    elsif mc <= QualifiedReference
      :defaults
    elsif mc <= AccessExpression
      # if Resource[e], then it is not resource specific
      lhs = expr[KEY_LEFT_EXPR]
      if lhs.model_class <= QualifiedReference && lhs[KEY_VALUE] == 'resource' && expr[KEY_KEYS].size == 1
        :defaults
      else
        :override
      end
    else
      :error
    end
  else
    :error
  end
end

.set_resource_form(expr, form) ⇒ Object

Sets the form of the resource expression (:regular (the default), :virtual, or :exported). Produces true if the expression was a resource expression, false otherwise.



646
647
648
649
650
651
652
 
# File 'lib/puppet/pops/model/factory.rb', line 646

def self.set_resource_form(expr, form)
  # Note: Validation handles illegal combinations
  return false unless expr.instance_of?(self) && expr.model_class <= AbstractResource

  expr['form'] = form
  true
end

.string(*args) ⇒ Object 



698
 
# File 'lib/puppet/pops/model/factory.rb', line 698

def self.string(*args);                new(ConcatenatedString, args.map { |arg| infer(arg) }); end

.STRING(*args) ⇒ Object 



720
 
# File 'lib/puppet/pops/model/factory.rb', line 720

def self.STRING(*args);                new(ConcatenatedString, args);                  end

.SUBLOCATE(token, expr_factory) ⇒ Object 



754
755
756
757
758
759
760
761
762
763
764
765
 
# File 'lib/puppet/pops/model/factory.rb', line 754

def self.SUBLOCATE(token, expr_factory)
  # expr is a Factory wrapped LiteralString, or ConcatenatedString
  # The token is SUBLOCATED token which has a SubLocator as the token's locator
  # Use the SubLocator to recalculate the offsets and lengths.
  model = expr_factory.model
  locator = token.locator
  expr_factory.map_offset(model, locator)
  model._pcore_all_contents([]) { |element| expr_factory.map_offset(element, locator) }

  # Returned the factory wrapping the now offset/length transformed expression(s)
  expr_factory
end

.TEXT(expr) ⇒ Object 



767
768
769
 
# File 'lib/puppet/pops/model/factory.rb', line 767

def self.TEXT(expr)
  new(TextExpression, infer(expr).interpolate)
end

.text(o) ⇒ Object 



700
 
# File 'lib/puppet/pops/model/factory.rb', line 700

def self.text(o);                      infer(o).text; end

.transform_calls(expressions) ⇒ Object

Transforms an array of expressions containing literal name expressions to calls if followed by an expression, or expression list.



1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
 
# File 'lib/puppet/pops/model/factory.rb', line 1009

def self.transform_calls(expressions)
  expressions.each_with_object([]) do |expr, memo|
    name = memo[-1]
    if name.instance_of?(Factory) && name.model_class <= QualifiedName && name_is_statement?(name[KEY_VALUE])
      if expr.is_a?(Array)
        expr = expr.reject { |e| e.is_a?(Parser::LexerSupport::TokenValue) }
      else
        expr = [expr]
      end
      the_call = self.CALL_NAMED(name, false, expr)
      # last positioned is last arg if there are several
      the_call.record_position(name[KEY_LOCATOR], name, expr[-1])
      memo[-1] = the_call
      if expr.is_a?(CallNamedFunctionExpression)
        # Patch statement function call to expression style
        # This is needed because it is first parsed as a "statement" and the requirement changes as it becomes
        # an argument to the name to call transform above.
        expr.rval_required = true
      end
    elsif expr.is_a?(Array)
      raise ArgsToNonCallError.new(expr, name)
    else
      memo << expr
      if expr.model_class <= CallNamedFunctionExpression
        # Patch rvalue expression function call to statement style.
        # This is not really required but done to be AST model compliant
        expr['rval_required'] = false
      end
    end
  end
end

.transform_resource_wo_title(left, attribute_ops, lbrace_token, rbrace_token) ⇒ Object

Transforms a left expression followed by an untitled resource (in the form of attribute_operations)

Parameters:



1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
 
# File 'lib/puppet/pops/model/factory.rb', line 1043

def self.transform_resource_wo_title(left, attribute_ops, lbrace_token, rbrace_token)
  # Returning nil means accepting the given as a potential resource expression
  return nil unless attribute_ops.is_a? Array
  return nil unless left.model_class <= QualifiedName

  keyed_entries = attribute_ops.map do |ao|
    return nil if ao[KEY_OPERATOR] == '+>'

    KEY_ENTRY(infer(ao['attribute_name']), ao['value_expr'])
  end
  a_hash = HASH(keyed_entries)
  a_hash.record_position(left[KEY_LOCATOR], lbrace_token, rbrace_token)
  block_or_expression(transform_calls([left, a_hash]))
end

.TYPE_ASSIGNMENT(lhs, rhs) ⇒ Object 



954
955
956
957
958
959
960
 
# File 'lib/puppet/pops/model/factory.rb', line 954

def self.TYPE_ASSIGNMENT(lhs, rhs)
  if lhs.model_class <= AccessExpression
    new(TypeMapping, lhs, rhs)
  else
    new(TypeAlias, lhs['cased_value'], rhs)
  end
end

.TYPE_DEFINITION(name, parent, body) ⇒ Object 



962
963
964
 
# File 'lib/puppet/pops/model/factory.rb', line 962

def self.TYPE_DEFINITION(name, parent, body)
  new(TypeDefinition, name, parent, body)
end

.unfold(o) ⇒ Object 



692
 
# File 'lib/puppet/pops/model/factory.rb', line 692

def self.unfold(o);                    infer(o).unfold;                                end

.UNLESS(test_e, then_e, else_e) ⇒ Object 



704
 
# File 'lib/puppet/pops/model/factory.rb', line 704

def self.UNLESS(test_e, then_e, else_e); new(UnlessExpression, test_e, then_e, else_e);  end

.var(o) ⇒ Object 



694
 
# File 'lib/puppet/pops/model/factory.rb', line 694

def self.var(o);                       infer(o).var;                                   end

.VIRTUAL_QUERY(query_expr) ⇒ Object 



839
840
841
 
# File 'lib/puppet/pops/model/factory.rb', line 839

def self.VIRTUAL_QUERY(query_expr)
  new(VirtualQuery, query_expr)
end

.WHEN(values_list, block) ⇒ Object 



708
 
# File 'lib/puppet/pops/model/factory.rb', line 708

def self.WHEN(values_list, block);     new(CaseOption, values_list, block);            end

Instance Method Details

#%(r) ⇒ Object 



557
 
# File 'lib/puppet/pops/model/factory.rb', line 557

def % r;      f_arithmetic('%', r);                           end

#*(r) ⇒ Object 



555
 
# File 'lib/puppet/pops/model/factory.rb', line 555

def * r;      f_arithmetic('*', r);                           end

#+(r) ⇒ Object 



549
 
# File 'lib/puppet/pops/model/factory.rb', line 549

def + r;      f_arithmetic('+', r);                           end

#-(r) ⇒ Object 



551
 
# File 'lib/puppet/pops/model/factory.rb', line 551

def - r;      f_arithmetic('-', r);                           end

#/(r) ⇒ Object 



553
 
# File 'lib/puppet/pops/model/factory.rb', line 553

def / r;      f_arithmetic('/', r);                           end

#<(r) ⇒ Object 



563
 
# File 'lib/puppet/pops/model/factory.rb', line 563

def < r;      f_comparison('<', r);                           end

#<<(r) ⇒ Object 



559
 
# File 'lib/puppet/pops/model/factory.rb', line 559

def << r;     f_arithmetic('<<', r);                          end

#<=(r) ⇒ Object 



565
 
# File 'lib/puppet/pops/model/factory.rb', line 565

def <= r;     f_comparison('<=', r);                          end

#=~(r) ⇒ Object 



575
 
# File 'lib/puppet/pops/model/factory.rb', line 575

def =~ r;     f_match('=~', r);                               end

#>(r) ⇒ Object 



567
 
# File 'lib/puppet/pops/model/factory.rb', line 567

def > r;      f_comparison('>', r);                           end

#>=(r) ⇒ Object 



569
 
# File 'lib/puppet/pops/model/factory.rb', line 569

def >= r;     f_comparison('>=', r);                          end

#>>(r) ⇒ Object 



561
 
# File 'lib/puppet/pops/model/factory.rb', line 561

def >> r;     f_arithmetic('>>', r);                          end

#[](key) ⇒ Object 



45
46
47
 
# File 'lib/puppet/pops/model/factory.rb', line 45

def [](key)
  @init_hash[key]
end

#[]=(key, value) ⇒ Object 



49
50
51
 
# File 'lib/puppet/pops/model/factory.rb', line 49

def []=(key, value)
  @init_hash[key] = value
end

#access(r) ⇒ Object 



545
 
# File 'lib/puppet/pops/model/factory.rb', line 545

def access(r); f_build_binary(AccessExpression, self, r);     end

#access_at(*r) ⇒ Object

Same as access, but with varargs and arguments that must be inferred. For testing purposes



590
591
592
 
# File 'lib/puppet/pops/model/factory.rb', line 590

def access_at(*r)
  f_build_binary(AccessExpression, self, r.map { |arg| Factory.infer(arg) })
end

#all_factories(&block) ⇒ Object 



53
54
55
56
 
# File 'lib/puppet/pops/model/factory.rb', line 53

def all_factories(&block)
  block.call(self)
  @init_hash.each_value { |value| value.all_factories(&block) if value.instance_of?(Factory) }
end

#and(r) ⇒ Object 



533
 
# File 'lib/puppet/pops/model/factory.rb', line 533

def and(r)    f_build_binary(AndExpression, self, r);         end

#attributes(*args) ⇒ Object 



619
620
621
622
 
# File 'lib/puppet/pops/model/factory.rb', line 619

def attributes(*args)
  @init_hash['attributes'] = args
  self
end

#build_AccessExpression(o, left, keys) ⇒ Object 



145
146
147
148
 
# File 'lib/puppet/pops/model/factory.rb', line 145

def build_AccessExpression(o, left, keys)
  @init_hash[KEY_LEFT_EXPR] = left
  @init_hash[KEY_KEYS] = keys
end

#build_ApplyExpression(o, args, body) ⇒ Object 



264
265
266
267
 
# File 'lib/puppet/pops/model/factory.rb', line 264

def build_ApplyExpression(o, args, body)
  @init_hash['arguments'] = args
  @init_hash['body'] = body
end

#build_ArithmeticExpression(o, op, a, b) ⇒ Object

Building of Model classes



125
126
127
128
 
# File 'lib/puppet/pops/model/factory.rb', line 125

def build_ArithmeticExpression(o, op, a, b)
  @init_hash[KEY_OPERATOR] = op
  build_BinaryExpression(o, a, b)
end

#build_AssignmentExpression(o, op, a, b) ⇒ Object 



130
131
132
133
 
# File 'lib/puppet/pops/model/factory.rb', line 130

def build_AssignmentExpression(o, op, a, b)
  @init_hash[KEY_OPERATOR] = op
  build_BinaryExpression(o, a, b)
end

#build_AttributeOperation(o, name, op, value) ⇒ Object 



135
136
137
138
139
 
# File 'lib/puppet/pops/model/factory.rb', line 135

def build_AttributeOperation(o, name, op, value)
  @init_hash[KEY_OPERATOR] = op
  @init_hash['attribute_name'] = name.to_s # BOOLEAN is allowed in the grammar
  @init_hash['value_expr'] = value
end

#build_AttributesOperation(o, value) ⇒ Object 



141
142
143
 
# File 'lib/puppet/pops/model/factory.rb', line 141

def build_AttributesOperation(o, value)
  @init_hash[KEY_EXPR] = value
end

#build_BinaryExpression(o, left, right) ⇒ Object 



150
151
152
153
 
# File 'lib/puppet/pops/model/factory.rb', line 150

def build_BinaryExpression(o, left, right)
  @init_hash[KEY_LEFT_EXPR] = left
  @init_hash[KEY_RIGHT_EXPR] = right
end

#build_BlockExpression(o, args) ⇒ Object 



155
156
157
 
# File 'lib/puppet/pops/model/factory.rb', line 155

def build_BlockExpression(o, args)
  @init_hash['statements'] = args
end

#build_CallExpression(o, functor, rval_required, args) ⇒ Object

Parameters:

  • rval_required (Boolean) —

    if the call must produce a value



166
167
168
169
170
 
# File 'lib/puppet/pops/model/factory.rb', line 166

def build_CallExpression(o, functor, rval_required, args)
  @init_hash['functor_expr'] = functor
  @init_hash['rval_required'] = rval_required
  @init_hash['arguments'] = args
end

#build_CallMethodExpression(o, functor, rval_required, lambda, args) ⇒ Object 



172
173
174
175
 
# File 'lib/puppet/pops/model/factory.rb', line 172

def build_CallMethodExpression(o, functor, rval_required, lambda, args)
  build_CallExpression(o, functor, rval_required, args)
  @init_hash['lambda'] = lambda
end

#build_CaseExpression(o, test, args) ⇒ Object 



177
178
179
180
 
# File 'lib/puppet/pops/model/factory.rb', line 177

def build_CaseExpression(o, test, args)
  @init_hash['test'] = test
  @init_hash['options'] = args
end

#build_CaseOption(o, value_list, then_expr) ⇒ Object 



182
183
184
185
186
187
 
# File 'lib/puppet/pops/model/factory.rb', line 182

def build_CaseOption(o, value_list, then_expr)
  value_list = [value_list] unless value_list.is_a?(Array)
  @init_hash['values'] = value_list
  b = f_build_body(then_expr)
  @init_hash['then_expr'] = b unless b.nil?
end

#build_CollectExpression(o, type_expr, query_expr, attribute_operations) ⇒ Object 



189
190
191
192
193
 
# File 'lib/puppet/pops/model/factory.rb', line 189

def build_CollectExpression(o, type_expr, query_expr, attribute_operations)
  @init_hash['type_expr'] = type_expr
  @init_hash['query'] = query_expr
  @init_hash['operations'] = attribute_operations
end

#build_ComparisonExpression(o, op, a, b) ⇒ Object 



195
196
197
198
 
# File 'lib/puppet/pops/model/factory.rb', line 195

def build_ComparisonExpression(o, op, a, b)
  @init_hash[KEY_OPERATOR] = op
  build_BinaryExpression(o, a, b)
end

#build_ConcatenatedString(o, args) ⇒ Object 



200
201
202
203
 
# File 'lib/puppet/pops/model/factory.rb', line 200

def build_ConcatenatedString(o, args)
  # Strip empty segments
  @init_hash['segments'] = args.reject { |arg| arg.model_class == LiteralString && arg['value'].empty? }
end

#build_EppExpression(o, parameters_specified, body) ⇒ Object 



159
160
161
162
163
 
# File 'lib/puppet/pops/model/factory.rb', line 159

def build_EppExpression(o, parameters_specified, body)
  @init_hash['parameters_specified'] = parameters_specified
  b = f_build_body(body)
  @init_hash[KEY_BODY] = b unless b.nil?
end

#build_FunctionDefinition(o, name, parameters, body, return_type) ⇒ Object 



369
370
371
372
373
374
375
 
# File 'lib/puppet/pops/model/factory.rb', line 369

def build_FunctionDefinition(o, name, parameters, body, return_type)
  @init_hash[KEY_PARAMETERS] = parameters
  b = f_build_body(body)
  @init_hash[KEY_BODY] = b unless b.nil?
  @init_hash[KEY_NAME] = name
  @init_hash['return_type'] = return_type unless return_type.nil?
end

#build_HeredocExpression(o, name, expr) ⇒ Object 



205
206
207
208
 
# File 'lib/puppet/pops/model/factory.rb', line 205

def build_HeredocExpression(o, name, expr)
  @init_hash['syntax'] = name
  @init_hash['text_expr'] = expr
end

#build_HostClassDefinition(o, name, parameters, parent_class_name, body) ⇒ HostClassDefinition

Returns configured from the parameters.

Parameters:

  • name (String) —

    a valid classname

  • parameters (Array<Parameter>) —

    may be empty

  • parent_class_name (String, nil) —

    a valid classname referencing a parent class, optional.

  • body (Array<Expression>, Expression, nil) —

    expression that constitute the body

Returns:



216
217
218
219
 
# File 'lib/puppet/pops/model/factory.rb', line 216

def build_HostClassDefinition(o, name, parameters, parent_class_name, body)
  build_NamedDefinition(o, name, parameters, body)
  @init_hash['parent_class'] = parent_class_name unless parent_class_name.nil?
end

#build_IfExpression(o, t, ift, els) ⇒ Object 



258
259
260
261
262
 
# File 'lib/puppet/pops/model/factory.rb', line 258

def build_IfExpression(o, t, ift, els)
  @init_hash['test'] = t
  @init_hash['then_expr'] = ift
  @init_hash['else_expr'] = els
end

#build_KeyedEntry(o, k, v) ⇒ Object 



231
232
233
234
 
# File 'lib/puppet/pops/model/factory.rb', line 231

def build_KeyedEntry(o, k, v)
  @init_hash['key'] = k
  @init_hash[KEY_VALUE] = v
end

#build_LambdaExpression(o, parameters, body, return_type) ⇒ Object 



355
356
357
358
359
360
 
# File 'lib/puppet/pops/model/factory.rb', line 355

def build_LambdaExpression(o, parameters, body, return_type)
  @init_hash[KEY_PARAMETERS] = parameters
  b = f_build_body(body)
  @init_hash[KEY_BODY] = b unless b.nil?
  @init_hash['return_type'] = return_type unless return_type.nil?
end

#build_LiteralFloat(o, val) ⇒ Object 



245
246
247
 
# File 'lib/puppet/pops/model/factory.rb', line 245

def build_LiteralFloat(o, val)
  @init_hash[KEY_VALUE] = val
end

#build_LiteralHash(o, keyed_entries, unfolded) ⇒ Object 



236
237
238
239
 
# File 'lib/puppet/pops/model/factory.rb', line 236

def build_LiteralHash(o, keyed_entries, unfolded)
  @init_hash['entries'] = keyed_entries
  @unfolded = unfolded
end

#build_LiteralInteger(o, val, radix) ⇒ Object 



249
250
251
252
 
# File 'lib/puppet/pops/model/factory.rb', line 249

def build_LiteralInteger(o, val, radix)
  @init_hash[KEY_VALUE] = val
  @init_hash['radix'] = radix
end

#build_LiteralList(o, values) ⇒ Object 



241
242
243
 
# File 'lib/puppet/pops/model/factory.rb', line 241

def build_LiteralList(o, values)
  @init_hash['values'] = values
end

#build_LiteralString(o, value) ⇒ Object 



254
255
256
 
# File 'lib/puppet/pops/model/factory.rb', line 254

def build_LiteralString(o, value)
  @init_hash[KEY_VALUE] = val
end

#build_MatchExpression(o, op, a, b) ⇒ Object 



269
270
271
272
 
# File 'lib/puppet/pops/model/factory.rb', line 269

def build_MatchExpression(o, op, a, b)
  @init_hash[KEY_OPERATOR] = op
  build_BinaryExpression(o, a, b)
end

#build_NamedDefinition(o, name, parameters, body) ⇒ Object 



362
363
364
365
366
367
 
# File 'lib/puppet/pops/model/factory.rb', line 362

def build_NamedDefinition(o, name, parameters, body)
  @init_hash[KEY_PARAMETERS] = parameters
  b = f_build_body(body)
  @init_hash[KEY_BODY] = b unless b.nil?
  @init_hash[KEY_NAME] = name
end

#build_NodeDefinition(o, hosts, parent, body) ⇒ Object 



385
386
387
388
389
390
 
# File 'lib/puppet/pops/model/factory.rb', line 385

def build_NodeDefinition(o, hosts, parent, body)
  @init_hash['host_matches'] = hosts
  @init_hash['parent'] = parent unless parent.nil? # no nop here
  b = f_build_body(body)
  @init_hash[KEY_BODY] = b unless b.nil?
end

#build_Parameter(o, name, expr) ⇒ Object 



392
393
394
395
 
# File 'lib/puppet/pops/model/factory.rb', line 392

def build_Parameter(o, name, expr)
  @init_hash[KEY_NAME] = name
  @init_hash[KEY_VALUE] = expr
end

#build_PlanDefinition(o, name, parameters, body, return_type = nil) ⇒ Object 



377
378
379
380
381
382
383
 
# File 'lib/puppet/pops/model/factory.rb', line 377

def build_PlanDefinition(o, name, parameters, body, return_type = nil)
  @init_hash[KEY_PARAMETERS] = parameters
  b = f_build_body(body)
  @init_hash[KEY_BODY] = b unless b.nil?
  @init_hash[KEY_NAME] = name
  @init_hash['return_type'] = return_type unless return_type.nil?
end

#build_Program(o, body, definitions, locator) ⇒ Object 



488
489
490
491
492
493
 
# File 'lib/puppet/pops/model/factory.rb', line 488

def build_Program(o, body, definitions, locator)
  @init_hash[KEY_BODY] = body
  # non containment
  @init_hash['definitions'] = definitions
  @init_hash[KEY_LOCATOR] = locator
end

#build_QualifiedName(o, name) ⇒ Object 



495
496
497
 
# File 'lib/puppet/pops/model/factory.rb', line 495

def build_QualifiedName(o, name)
  @init_hash[KEY_VALUE] = name
end

#build_QualifiedReference(o, name) ⇒ Object 



397
398
399
 
# File 'lib/puppet/pops/model/factory.rb', line 397

def build_QualifiedReference(o, name)
  @init_hash['cased_value'] = name.to_s
end

#build_QueryExpression(o, expr) ⇒ Object 



435
436
437
 
# File 'lib/puppet/pops/model/factory.rb', line 435

def build_QueryExpression(o, expr)
  @init_hash[KEY_EXPR] = expr unless Factory.nop?(expr)
end

#build_RelationshipExpression(o, op, a, b) ⇒ Object 



401
402
403
404
 
# File 'lib/puppet/pops/model/factory.rb', line 401

def build_RelationshipExpression(o, op, a, b)
  @init_hash[KEY_OPERATOR] = op
  build_BinaryExpression(o, a, b)
end

#build_RenderStringExpression(o, string) ⇒ Object 



411
412
413
 
# File 'lib/puppet/pops/model/factory.rb', line 411

def build_RenderStringExpression(o, string)
  @init_hash[KEY_VALUE] = string;
end

#build_ReservedWord(o, name, future) ⇒ Object 



226
227
228
229
 
# File 'lib/puppet/pops/model/factory.rb', line 226

def build_ReservedWord(o, name, future)
  @init_hash['word'] = name
  @init_hash['future'] = future
end

#build_ResourceBody(o, title_expression, attribute_operations) ⇒ Object 



415
416
417
418
 
# File 'lib/puppet/pops/model/factory.rb', line 415

def build_ResourceBody(o, title_expression, attribute_operations)
  @init_hash['title'] = title_expression
  @init_hash['operations'] = attribute_operations
end

#build_ResourceDefaultsExpression(o, type_ref, attribute_operations) ⇒ Object 



420
421
422
423
 
# File 'lib/puppet/pops/model/factory.rb', line 420

def build_ResourceDefaultsExpression(o, type_ref, attribute_operations)
  @init_hash['type_ref'] = type_ref
  @init_hash['operations'] = attribute_operations
end

#build_ResourceExpression(o, type_name, bodies) ⇒ Object 



406
407
408
409
 
# File 'lib/puppet/pops/model/factory.rb', line 406

def build_ResourceExpression(o, type_name, bodies)
  @init_hash['type_name'] = type_name
  @init_hash['bodies'] = bodies
end

#build_ResourceOverrideExpression(o, resources, attribute_operations) ⇒ Object 



221
222
223
224
 
# File 'lib/puppet/pops/model/factory.rb', line 221

def build_ResourceOverrideExpression(o, resources, attribute_operations)
  @init_hash['resources'] = resources
  @init_hash['operations'] = attribute_operations
end

#build_SelectorEntry(o, matching, value) ⇒ Object 



430
431
432
433
 
# File 'lib/puppet/pops/model/factory.rb', line 430

def build_SelectorEntry(o, matching, value)
  @init_hash['matching_expr'] = matching
  @init_hash['value_expr'] = value
end

#build_SelectorExpression(o, left, *selectors) ⇒ Object 



425
426
427
428
 
# File 'lib/puppet/pops/model/factory.rb', line 425

def build_SelectorExpression(o, left, *selectors)
  @init_hash[KEY_LEFT_EXPR] = left
  @init_hash['selectors'] = selectors
end

#build_TokenValue(o) ⇒ Object 



499
500
501
 
# File 'lib/puppet/pops/model/factory.rb', line 499

def build_TokenValue(o)
  raise "Factory can not deal with a Lexer Token. Got token: #{o}. Probably caused by wrong index in grammar val[n]."
end

#build_TypeAlias(o, name, type_expr) ⇒ Object 



439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
 
# File 'lib/puppet/pops/model/factory.rb', line 439

def build_TypeAlias(o, name, type_expr)
  if type_expr.model_class <= KeyedEntry
    # KeyedEntry is used for the form:
    #
    #   type Foo = Bar { ... }
    #
    # The entry contains Bar => { ... } and must be transformed into:
    #
    #   Object[{parent => Bar, ... }]
    #
    parent = type_expr['key']
    hash = type_expr['value']
    pn = parent['cased_value']
    unless pn == 'Object' || pn == 'TypeSet'
      hash['entries'] << Factory.KEY_ENTRY(Factory.QNAME('parent'), parent)
      parent = Factory.QREF('Object')
    end
    type_expr = parent.access([hash])
  elsif type_expr.model_class <= LiteralHash
    # LiteralHash is used for the form:
    #
    #   type Foo = { ... }
    #
    # The hash must be transformed into:
    #
    #   Object[{ ... }]
    #
    type_expr = Factory.QREF('Object').access([type_expr])
  end
  @init_hash['type_expr'] = type_expr
  @init_hash[KEY_NAME] = name
end

#build_TypeDefinition(o, name, parent, body) ⇒ Object 



477
478
479
480
481
482
 
# File 'lib/puppet/pops/model/factory.rb', line 477

def build_TypeDefinition(o, name, parent, body)
  b = f_build_body(body)
  @init_hash[KEY_BODY] = b unless b.nil?
  @init_hash['parent'] = parent
  @init_hash[KEY_NAME] = name
end

#build_TypeMapping(o, lhs, rhs) ⇒ Object 



472
473
474
475
 
# File 'lib/puppet/pops/model/factory.rb', line 472

def build_TypeMapping(o, lhs, rhs)
  @init_hash['type_expr'] = lhs
  @init_hash['mapping_expr'] = rhs
end

#build_UnaryExpression(o, expr) ⇒ Object 



484
485
486
 
# File 'lib/puppet/pops/model/factory.rb', line 484

def build_UnaryExpression(o, expr)
  @init_hash[KEY_EXPR] = expr unless Factory.nop?(expr)
end

#captures_rest ⇒ Object

Mark parameter as capturing the rest of arguments



731
732
733
 
# File 'lib/puppet/pops/model/factory.rb', line 731

def captures_rest
  @init_hash['captures_rest'] = true
end

#contained_current(container) ⇒ Object 



1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
 
# File 'lib/puppet/pops/model/factory.rb', line 1144

def contained_current(container)
  if @current.nil?
    unless @init_hash.include?(KEY_LOCATOR)
      @init_hash[KEY_LOCATOR] = container[KEY_LOCATOR]
      @init_hash[KEY_OFFSET] = container[KEY_OFFSET] || 0
      @init_hash[KEY_LENGTH] = 0
    end
    @current = create_model
  end
  @current
end

#create_model ⇒ Object 



77
78
79
80
 
# File 'lib/puppet/pops/model/factory.rb', line 77

def create_model
  @init_hash.each_pair { |key, elem| @init_hash[key] = factory_to_model(elem) }
  model_class.from_asserted_hash(@init_hash)
end

#default(r) ⇒ Object

For CaseExpression, setting the default for an already build CaseExpression



595
596
597
598
 
# File 'lib/puppet/pops/model/factory.rb', line 595

def default(r)
  @init_hash['options'] << Factory.WHEN(Factory.infer(:default), r)
  self
end

#dot(r) ⇒ Object 



547
 
# File 'lib/puppet/pops/model/factory.rb', line 547

def dot r;    f_build_binary(NamedAccessExpression, self, r); end

#eq(r) ⇒ Object 



571
 
# File 'lib/puppet/pops/model/factory.rb', line 571

def eq r;     f_comparison('==', r);                          end

#f_arithmetic(op, r) ⇒ Object 



516
517
518
 
# File 'lib/puppet/pops/model/factory.rb', line 516

def f_arithmetic(op, r)
  f_build_binary_op(ArithmeticExpression, op, self, r)
end

#f_build_binary(klazz, left, right) ⇒ Object 



512
513
514
 
# File 'lib/puppet/pops/model/factory.rb', line 512

def f_build_binary(klazz, left, right)
  Factory.new(klazz, left, right)
end

#f_build_binary_op(klazz, op, left, right) ⇒ Object 



508
509
510
 
# File 'lib/puppet/pops/model/factory.rb', line 508

def f_build_binary_op(klazz, op, left, right)
  Factory.new(klazz, op, left, right)
end

#f_build_body(body) ⇒ Object 



342
343
344
345
346
347
348
349
350
351
352
353
 
# File 'lib/puppet/pops/model/factory.rb', line 342

def f_build_body(body)
  case body
  when NilClass
    nil
  when Array
    Factory.new(BlockExpression, body)
  when Factory
    body
  else
    Factory.infer(body)
  end
end

#f_build_unary(klazz, expr) ⇒ Object

Factory helpers



504
505
506
 
# File 'lib/puppet/pops/model/factory.rb', line 504

def f_build_unary(klazz, expr)
  Factory.new(klazz, expr)
end

#f_comparison(op, r) ⇒ Object 



520
521
522
 
# File 'lib/puppet/pops/model/factory.rb', line 520

def f_comparison(op, r)
  f_build_binary_op(ComparisonExpression, op, self, r)
end

#f_match(op, r) ⇒ Object 



524
525
526
 
# File 'lib/puppet/pops/model/factory.rb', line 524

def f_match(op, r)
  f_build_binary_op(MatchExpression, op, self, r)
end

#factory_to_model(value) ⇒ Object 



1134
1135
1136
1137
1138
1139
1140
1141
1142
 
# File 'lib/puppet/pops/model/factory.rb', line 1134

def factory_to_model(value)
  if value.instance_of?(Factory)
    value.contained_current(self)
  elsif value.instance_of?(Array)
    value.each_with_index { |el, idx| value[idx] = el.contained_current(self) if el.instance_of?(Factory) }
  else
    value
  end
end

#in(r) ⇒ Object

Operator helpers



529
 
# File 'lib/puppet/pops/model/factory.rb', line 529

def in(r)     f_build_binary(InExpression, self, r);          end

#infer_Array(o) ⇒ Object

Creates a LiteralList instruction from an Array, where the entries are built.



328
329
330
331
 
# File 'lib/puppet/pops/model/factory.rb', line 328

def infer_Array(o)
  @model_class = LiteralList
  @init_hash['values'] = o.map { |e| Factory.infer(e) }
end

#infer_FalseClass(o) ⇒ Object 



292
293
294
295
 
# File 'lib/puppet/pops/model/factory.rb', line 292

def infer_FalseClass(o)
  @model_class = LiteralBoolean
  @init_hash[KEY_VALUE] = o
end

#infer_Float(o) ⇒ Object 



302
303
304
305
 
# File 'lib/puppet/pops/model/factory.rb', line 302

def infer_Float(o)
  @model_class = LiteralFloat
  @init_hash[KEY_VALUE] = o
end

#infer_Hash(o) ⇒ Object

Create a LiteralHash instruction from a hash, where keys and values are built The hash entries are added in sorted order based on key.to_s



336
337
338
339
340
 
# File 'lib/puppet/pops/model/factory.rb', line 336

def infer_Hash(o)
  @model_class = LiteralHash
  @init_hash['entries'] = o.sort_by { |k, _| k.to_s }.map { |k, v| Factory.new(KeyedEntry, Factory.infer(k), Factory.infer(v)) }
  @unfolded = false
end

#infer_Integer(o) ⇒ Object 



297
298
299
300
 
# File 'lib/puppet/pops/model/factory.rb', line 297

def infer_Integer(o)
  @model_class = LiteralInteger
  @init_hash[KEY_VALUE] = o
end

#infer_NilClass(o) ⇒ Object 



283
284
285
 
# File 'lib/puppet/pops/model/factory.rb', line 283

def infer_NilClass(o)
  @model_class = Nop
end

#infer_Regexp(o) ⇒ Object 



307
308
309
310
311
 
# File 'lib/puppet/pops/model/factory.rb', line 307

def infer_Regexp(o)
  @model_class = LiteralRegularExpression
  @init_hash['pattern'] = o.inspect
  @init_hash[KEY_VALUE] = o
end

#infer_String(o) ⇒ Object

Building model equivalences of Ruby objects Allows passing regular ruby objects to the factory to produce instructions that when evaluated produce the same thing.



278
279
280
281
 
# File 'lib/puppet/pops/model/factory.rb', line 278

def infer_String(o)
  @model_class = LiteralString
  @init_hash[KEY_VALUE] = o
end

#infer_Symbol(o) ⇒ Object

Creates a String literal, unless the symbol is one of the special :undef, or :default which instead creates a LiterlUndef, or a LiteralDefault. Supports :undef because nil creates a no-op instruction.



316
317
318
319
320
321
322
323
324
325
 
# File 'lib/puppet/pops/model/factory.rb', line 316

def infer_Symbol(o)
  case o
  when :undef
    @model_class = LiteralUndef
  when :default
    @model_class = LiteralDefault
  else
    infer_String(o.to_s)
  end
end

#infer_TrueClass(o) ⇒ Object 



287
288
289
290
 
# File 'lib/puppet/pops/model/factory.rb', line 287

def infer_TrueClass(o)
  @model_class = LiteralBoolean
  @init_hash[KEY_VALUE] = o
end

#interpolate ⇒ Object

Polymorphic interpolate



119
120
121
 
# File 'lib/puppet/pops/model/factory.rb', line 119

def interpolate
  INTERPOLATION_VISITOR.visit_this_class(self, @model_class, EMPTY_ARRAY)
end

#interpolate_AccessExpression(c) ⇒ Object

rewrite left expression to variable if it is name, number, and recurse if it is an access expression this is for interpolation support in new lexer ($NAME, $NAME[}, $NUMBER, $NUMBER[] - all other expressions requires variables to be preceded with $



1079
1080
1081
1082
1083
1084
1085
 
# File 'lib/puppet/pops/model/factory.rb', line 1079

def interpolate_AccessExpression(c)
  lhs = @init_hash[KEY_LEFT_EXPR]
  if is_interop_rewriteable?(lhs)
    @init_hash[KEY_LEFT_EXPR] = lhs.interpolate
  end
  self
end

#interpolate_CallMethodExpression(c) ⇒ Object

Rewrite method calls on the form $… to $Puppet::Pops::Model::Factory.$x$x.each



1096
1097
1098
1099
1100
1101
1102
 
# File 'lib/puppet/pops/model/factory.rb', line 1096

def interpolate_CallMethodExpression(c)
  functor_expr = @init_hash['functor_expr']
  if is_interop_rewriteable?(functor_expr)
    @init_hash['functor_expr'] = functor_expr.interpolate
  end
  self
end

#interpolate_Factory(c) ⇒ Object 



1058
1059
1060
 
# File 'lib/puppet/pops/model/factory.rb', line 1058

def interpolate_Factory(c)
  self
end

#interpolate_LiteralInteger(c) ⇒ Object 



1062
1063
1064
1065
 
# File 'lib/puppet/pops/model/factory.rb', line 1062

def interpolate_LiteralInteger(c)
  # convert number to a variable
  var
end

#interpolate_NamedAccessExpression(c) ⇒ Object 



1087
1088
1089
1090
1091
1092
1093
 
# File 'lib/puppet/pops/model/factory.rb', line 1087

def interpolate_NamedAccessExpression(c)
  lhs = @init_hash[KEY_LEFT_EXPR]
  if is_interop_rewriteable?(lhs)
    @init_hash[KEY_LEFT_EXPR] = lhs.interpolate
  end
  self
end

#interpolate_Object(c) ⇒ Object 



1067
1068
1069
 
# File 'lib/puppet/pops/model/factory.rb', line 1067

def interpolate_Object(c)
  self
end

#interpolate_QualifiedName(c) ⇒ Object 



1071
1072
1073
 
# File 'lib/puppet/pops/model/factory.rb', line 1071

def interpolate_QualifiedName(c)
  var
end

#is_interop_rewriteable?(o) ⇒ Boolean

Returns:

  • (Boolean) 


1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
 
# File 'lib/puppet/pops/model/factory.rb', line 1104

def is_interop_rewriteable?(o)
  mc = o.model_class
  if mc <= AccessExpression || mc <= QualifiedName || mc <= NamedAccessExpression || mc <= CallMethodExpression
    true
  elsif mc <= LiteralInteger
    # Only decimal integers can represent variables, else it is a number
    o['radix'] == 10
  else
    false
  end
end

#lambda=(lambda) ⇒ Object 



600
601
602
 
# File 'lib/puppet/pops/model/factory.rb', line 600

def lambda=(lambda)
  @init_hash['lambda'] = lambda
end

#length ⇒ Object 



628
629
630
 
# File 'lib/puppet/pops/model/factory.rb', line 628

def length
  @init_hash[KEY_LENGTH]
end

#map_offset(model, locator) ⇒ Object 



95
96
97
 
# File 'lib/puppet/pops/model/factory.rb', line 95

def map_offset(model, locator)
  MAPOFFSET_VISITOR.visit_this_1(self, model, locator)
end

#map_offset_Factory(o, locator) ⇒ Object 



103
104
105
 
# File 'lib/puppet/pops/model/factory.rb', line 103

def map_offset_Factory(o, locator)
  map_offset(o.model, locator)
end

#map_offset_Object(o, locator) ⇒ Object 



99
100
101
 
# File 'lib/puppet/pops/model/factory.rb', line 99

def map_offset_Object(o, locator)
  o
end

#map_offset_Positioned(o, locator) ⇒ Object 



107
108
109
110
111
112
113
114
115
116
 
# File 'lib/puppet/pops/model/factory.rb', line 107

def map_offset_Positioned(o, locator)
  # Transpose the local offset, length to global "coordinates"
  global_offset, global_length = locator.to_global(o.offset, o.length)

  # mutate
  o.instance_variable_set(:'@offset', global_offset)
  o.instance_variable_set(:'@length', global_length)
  # Change locator since the positions were transposed to the global coordinates
  o.instance_variable_set(:'@locator', locator.locator) if locator.is_a? Puppet::Pops::Parser::Locator::SubLocator
end

#minus ⇒ Object 



537
 
# File 'lib/puppet/pops/model/factory.rb', line 537

def minus();  f_build_unary(UnaryMinusExpression, self);      end

#minus_set(r) ⇒ Object

Assignment -=



615
616
617
 
# File 'lib/puppet/pops/model/factory.rb', line 615

def minus_set(r)
  f_build_binary_op(AssignmentExpression, '-=', self, r)
end

#mne(r) ⇒ Object 



577
 
# File 'lib/puppet/pops/model/factory.rb', line 577

def mne r;    f_match('!~', r);                               end

#model ⇒ Object Also known as: current 



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/puppet/pops/model/factory.rb', line 58

def model
  if @current.nil?
    # Assign a default Locator if it's missing. Should only happen when the factory is used by other
    # means than from a parser (e.g. unit tests)
    unless @init_hash.include?(KEY_LOCATOR)
      @init_hash[KEY_LOCATOR] = Parser::Locator.locator('<no source>', 'no file')
      unless @model_class <= Program
        @init_hash[KEY_OFFSET] = 0
        @init_hash[KEY_LENGTH] = 0
      end
    end
    @current = create_model
  end
  @current
end

#ne(r) ⇒ Object 



573
 
# File 'lib/puppet/pops/model/factory.rb', line 573

def ne r;     f_comparison('!=', r);                          end

#not ⇒ Object 



535
 
# File 'lib/puppet/pops/model/factory.rb', line 535

def not();    f_build_unary(NotExpression, self);             end

#offset ⇒ Object 



624
625
626
 
# File 'lib/puppet/pops/model/factory.rb', line 624

def offset
  @init_hash[KEY_OFFSET]
end

#or(r) ⇒ Object 



531
 
# File 'lib/puppet/pops/model/factory.rb', line 531

def or(r)     f_build_binary(OrExpression, self, r);          end

#paren ⇒ Object 



579
 
# File 'lib/puppet/pops/model/factory.rb', line 579

def paren;    f_build_unary(ParenthesizedExpression, self);   end

#plus_set(r) ⇒ Object

Assignment +=



610
611
612
 
# File 'lib/puppet/pops/model/factory.rb', line 610

def plus_set(r)
  f_build_binary_op(AssignmentExpression, '+=', self, r)
end

#record_position(locator, start_locatable, end_locatable) ⇒ Object

Records the position (start -> end) and computes the resulting length.



634
635
636
637
638
639
640
641
 
# File 'lib/puppet/pops/model/factory.rb', line 634

def record_position(locator, start_locatable, end_locatable)
  # record information directly in the Positioned object
  start_offset = start_locatable.offset
  @init_hash[KEY_LOCATOR] = locator
  @init_hash[KEY_OFFSET] = start_offset
  @init_hash[KEY_LENGTH] = end_locatable.nil? ? start_locatable.length : end_locatable.offset + end_locatable.length - start_offset
  self
end

#relop(op, r) ⇒ Object 



581
582
583
 
# File 'lib/puppet/pops/model/factory.rb', line 581

def relop(op, r)
  f_build_binary_op(RelationshipExpression, op, self, r)
end

#select(*args) ⇒ Object 



585
586
587
 
# File 'lib/puppet/pops/model/factory.rb', line 585

def select(*args)
  Factory.new(SelectorExpression, self, *args)
end

#set(r) ⇒ Object

Assignment =



605
606
607
 
# File 'lib/puppet/pops/model/factory.rb', line 605

def set(r)
  f_build_binary_op(AssignmentExpression, '=', self, r)
end

#text ⇒ Object 



541
 
# File 'lib/puppet/pops/model/factory.rb', line 541

def text();   f_build_unary(TextExpression, self);            end

#to_s ⇒ Object 



1130
1131
1132
 
# File 'lib/puppet/pops/model/factory.rb', line 1130

def to_s
  "Factory for #{@model_class}"
end

#type_expr(o) ⇒ Object

Set Expression that should evaluate to the parameter’s type



736
737
738
 
# File 'lib/puppet/pops/model/factory.rb', line 736

def type_expr(o)
  @init_hash['type_expr'] = o
end

#unfold ⇒ Object 



539
 
# File 'lib/puppet/pops/model/factory.rb', line 539

def unfold(); f_build_unary(UnfoldExpression, self);          end

#var ⇒ Object 



543
 
# File 'lib/puppet/pops/model/factory.rb', line 543

def var();    f_build_unary(VariableExpression, self);        end