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'.freeze
KEY_OFFSET =
'offset'.freeze
KEY_LOCATOR =
'locator'.freeze
KEY_OPERATOR =
'operator'.freeze
KEY_VALUE =
'value'.freeze
KEY_KEYS =
'keys'.freeze
KEY_NAME =
'name'.freeze
KEY_BODY =
'body'.freeze
KEY_EXPR =
'expr'.freeze
KEY_LEFT_EXPR =
'left_expr'.freeze
KEY_RIGHT_EXPR =
'right_expr'.freeze
KEY_PARAMETERS =
'parameters'.freeze
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


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

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_classObject (readonly)


41
42
43
# File 'lib/puppet/pops/model/factory.rb', line 41

def model_class
  @model_class
end

#unfoldedObject (readonly)


41
42
43
# File 'lib/puppet/pops/model/factory.rb', line 41

def unfolded
  @unfolded
end

Class Method Details

.APPLICATION(name, parameters, body) ⇒ Object


973
974
975
# File 'lib/puppet/pops/model/factory.rb', line 973

def self.APPLICATION(name, parameters, body)
  new(Application, name, parameters, body)
end

.APPLY(arguments, body) ⇒ Object


981
982
983
# File 'lib/puppet/pops/model/factory.rb', line 981

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

.APPLY_BLOCK(statements) ⇒ Object


985
986
987
# File 'lib/puppet/pops/model/factory.rb', line 985

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

.ARGUMENTS(args, arg) ⇒ Object


882
883
884
885
886
887
888
889
890
891
# File 'lib/puppet/pops/model/factory.rb', line 882

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


893
894
895
# File 'lib/puppet/pops/model/factory.rb', line 893

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

.ATTRIBUTES_OP(expr) ⇒ Object


897
898
899
# File 'lib/puppet/pops/model/factory.rb', line 897

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

.block(*args) ⇒ Object


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

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


943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
# File 'lib/puppet/pops/model/factory.rb', line 943

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


910
911
912
# File 'lib/puppet/pops/model/factory.rb', line 910

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

.CALL_NAMED(name, rval_required, argument_list) ⇒ Object


906
907
908
# File 'lib/puppet/pops/model/factory.rb', line 906

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)


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

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

.CAPABILITY_MAPPING(kind, component, cap_name, mappings) ⇒ Object


969
970
971
# File 'lib/puppet/pops/model/factory.rb', line 969

def self.CAPABILITY_MAPPING(kind, component, cap_name, mappings)
  new(CapabilityMapping, kind, component, cap_name, mappings)
end

.CASE(test_e, *options) ⇒ Object


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

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

.COLLECT(type_expr, query_expr, attribute_operations) ⇒ Object


914
915
916
# File 'lib/puppet/pops/model/factory.rb', line 914

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

.concat(*args) ⇒ Object


1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
# File 'lib/puppet/pops/model/factory.rb', line 1158

def self.concat(*args)
  result = ''
  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


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

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

.EPP(parameters, body) ⇒ Object


815
816
817
818
819
820
821
822
823
824
# File 'lib/puppet/pops/model/factory.rb', line 815

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


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

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.


778
779
780
# File 'lib/puppet/pops/model/factory.rb', line 778

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.


785
786
787
# File 'lib/puppet/pops/model/factory.rb', line 785

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

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


989
990
991
# File 'lib/puppet/pops/model/factory.rb', line 989

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

.HASH(entries) ⇒ Object


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

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

.HASH_UNFOLDED(entries) ⇒ Object


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

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

.HEREDOC(name, expr) ⇒ Object


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

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

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


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

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

.IF(test_e, then_e, else_e) ⇒ Object


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

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

.infer(o) ⇒ Object


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

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

.KEY_ENTRY(key, val) ⇒ Object


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

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

.LAMBDA(parameters, body, return_type) ⇒ Object


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

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

.LIST(entries) ⇒ Object


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

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

.literal(o) ⇒ Object

Factory starting points


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

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

.MAP(match, value) ⇒ Object


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

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

.minus(o) ⇒ Object


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

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


1036
1037
1038
# File 'lib/puppet/pops/model/factory.rb', line 1036

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

.NAMED_ACCESS(type_name, bodies) ⇒ Object


918
919
920
# File 'lib/puppet/pops/model/factory.rb', line 918

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

.NODE(hosts, parent, body) ⇒ Object


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

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

.nop?(o) ⇒ Boolean


1009
1010
1011
# File 'lib/puppet/pops/model/factory.rb', line 1009

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

.NUMBER(name_or_numeric) ⇒ Object


837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
# File 'lib/puppet/pops/model/factory.rb', line 837

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


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

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

.PLAN(name, parameters, body) ⇒ Object


977
978
979
# File 'lib/puppet/pops/model/factory.rb', line 977

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

.PROGRAM(body, definitions, locator) ⇒ Object


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

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.


833
834
835
# File 'lib/puppet/pops/model/factory.rb', line 833

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


856
857
858
859
860
861
862
863
864
865
866
867
868
# File 'lib/puppet/pops/model/factory.rb', line 856

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


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

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

.RENDER_EXPR(expr) ⇒ Object


811
812
813
# File 'lib/puppet/pops/model/factory.rb', line 811

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

.RENDER_STRING(o) ⇒ Object

TODO_EPP


807
808
809
# File 'lib/puppet/pops/model/factory.rb', line 807

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

.RESERVED(name, future = false) ⇒ Object


826
827
828
# File 'lib/puppet/pops/model/factory.rb', line 826

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

.RESOURCE(type_name, bodies) ⇒ Object


922
923
924
# File 'lib/puppet/pops/model/factory.rb', line 922

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

.RESOURCE_BODY(resource_title, attribute_operations) ⇒ Object


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

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

.RESOURCE_DEFAULTS(type_name, attribute_operations) ⇒ Object


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

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

.RESOURCE_OVERRIDE(resource_ref, attribute_operations) ⇒ Object


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

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


694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
# File 'lib/puppet/pops/model/factory.rb', line 694

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.


680
681
682
683
684
685
# File 'lib/puppet/pops/model/factory.rb', line 680

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
  return true
end

.SITE(body) ⇒ Object


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

def self.SITE(body);                   new(SiteDefinition, body);                      end

.string(*args) ⇒ Object


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

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

.STRING(*args) ⇒ Object


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

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

.SUBLOCATE(token, expr_factory) ⇒ Object


789
790
791
792
793
794
795
796
797
798
799
800
# File 'lib/puppet/pops/model/factory.rb', line 789

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


802
803
804
# File 'lib/puppet/pops/model/factory.rb', line 802

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

.text(o) ⇒ Object


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

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.


1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
# File 'lib/puppet/pops/model/factory.rb', line 1051

def self.transform_calls(expressions)
  expressions.reduce([]) do |memo, expr|
    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
    memo
  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)


1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
# File 'lib/puppet/pops/model/factory.rb', line 1086

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)
  result = block_or_expression(transform_calls([left, a_hash]))
  result
end

.TYPE_ASSIGNMENT(lhs, rhs) ⇒ Object


997
998
999
1000
1001
1002
1003
# File 'lib/puppet/pops/model/factory.rb', line 997

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


1005
1006
1007
# File 'lib/puppet/pops/model/factory.rb', line 1005

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

.unfold(o) ⇒ Object


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

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

.UNLESS(test_e, then_e, else_e) ⇒ Object


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

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

.var(o) ⇒ Object


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

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

.VIRTUAL_QUERY(query_expr) ⇒ Object


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

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

.WHEN(values_list, block) ⇒ Object


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

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

Instance Method Details

#%(r) ⇒ Object


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

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

#*(r) ⇒ Object


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

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

#+(r) ⇒ Object


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

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

#-(r) ⇒ Object


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

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

#/(r) ⇒ Object


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

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

#<(r) ⇒ Object


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

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

#<<(r) ⇒ Object


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

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

#<=(r) ⇒ Object


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

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

#=~(r) ⇒ Object


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

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

#>(r) ⇒ Object


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

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

#>=(r) ⇒ Object


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

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

#>>(r) ⇒ Object


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

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

#[](key) ⇒ Object


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

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

#[]=(key, value) ⇒ Object


47
48
49
# File 'lib/puppet/pops/model/factory.rb', line 47

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

#access(r) ⇒ Object


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

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


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

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

#all_factories(&block) ⇒ Object


51
52
53
54
# File 'lib/puppet/pops/model/factory.rb', line 51

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


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

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

#attributes(*args) ⇒ Object


653
654
655
656
# File 'lib/puppet/pops/model/factory.rb', line 653

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

#build_AccessExpression(o, left, keys) ⇒ Object


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

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

#build_Application(o, n, ps, body) ⇒ Object

Building of Model classes


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

def build_Application(o, n, ps, body)
  @init_hash[KEY_NAME] = n
  @init_hash[KEY_PARAMETERS] = ps
  b = f_build_body(body)
  @init_hash[KEY_BODY] = b unless b.nil?
end

#build_ApplyExpression(o, args, body) ⇒ Object


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

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

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


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

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


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

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


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

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


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

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

#build_BinaryExpression(o, left, right) ⇒ Object


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

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

#build_BlockExpression(o, args) ⇒ Object


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

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

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


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

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


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

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

#build_CapabilityMapping(o, kind, component, capability, mappings) ⇒ Object


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

def build_CapabilityMapping(o, kind, component, capability, mappings)
  @init_hash['kind'] = kind
  @init_hash['component'] = component
  @init_hash['capability'] = capability
  @init_hash['mappings'] = mappings
end

#build_CaseExpression(o, test, args) ⇒ Object


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

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

#build_CaseOption(o, value_list, then_expr) ⇒ Object


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

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


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

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


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

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

#build_ConcatenatedString(o, args) ⇒ Object


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

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


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

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


374
375
376
377
378
379
380
# File 'lib/puppet/pops/model/factory.rb', line 374

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


210
211
212
213
# File 'lib/puppet/pops/model/factory.rb', line 210

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


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

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


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

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


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

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

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


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

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


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

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

#build_LiteralHash(o, keyed_entries, unfolded) ⇒ Object


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

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

#build_LiteralInteger(o, val, radix) ⇒ Object


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

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

#build_LiteralList(o, values) ⇒ Object


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

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

#build_LiteralString(o, value) ⇒ Object


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

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

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


274
275
276
277
# File 'lib/puppet/pops/model/factory.rb', line 274

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


367
368
369
370
371
372
# File 'lib/puppet/pops/model/factory.rb', line 367

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


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

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


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

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


382
383
384
385
386
387
388
# File 'lib/puppet/pops/model/factory.rb', line 382

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


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

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


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

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

#build_QualifiedReference(o, name) ⇒ Object


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

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

#build_QueryExpression(o, expr) ⇒ Object


468
469
470
# File 'lib/puppet/pops/model/factory.rb', line 468

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

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


418
419
420
421
# File 'lib/puppet/pops/model/factory.rb', line 418

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

#build_RenderStringExpression(o, string) ⇒ Object


428
429
430
# File 'lib/puppet/pops/model/factory.rb', line 428

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

#build_ReservedWord(o, name, future) ⇒ Object


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

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

#build_ResourceBody(o, title_expression, attribute_operations) ⇒ Object


432
433
434
435
# File 'lib/puppet/pops/model/factory.rb', line 432

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


437
438
439
440
# File 'lib/puppet/pops/model/factory.rb', line 437

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


423
424
425
426
# File 'lib/puppet/pops/model/factory.rb', line 423

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


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

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

#build_SelectorEntry(o, matching, value) ⇒ Object


463
464
465
466
# File 'lib/puppet/pops/model/factory.rb', line 463

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

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


442
443
444
445
# File 'lib/puppet/pops/model/factory.rb', line 442

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

#build_SiteDefinition(o, body) ⇒ Object


404
405
406
407
# File 'lib/puppet/pops/model/factory.rb', line 404

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

#build_SubLocatedExpression(o, token, expression) ⇒ Object

Builds a SubLocatedExpression - this wraps the expression in a sublocation configured from the given token A SubLocated holds its own locator that is used for subexpressions holding positions relative to what it describes.


452
453
454
455
456
457
458
459
460
461
# File 'lib/puppet/pops/model/factory.rb', line 452

def build_SubLocatedExpression(o, token, expression)
  @init_hash[KEY_EXPR] = expression
  @init_hash[KEY_OFFSET] = token.offset
  @init_hash[KEY_LENGTH] =  token.length
  locator = token.locator
  @init_hash[KEY_LOCATOR] = locator
  @init_hash['leading_line_count'] = locator.leading_line_count
  @init_hash['leading_line_offset'] = locator.leading_line_offset
  @init_hash['line_offsets'] = locator.line_index # index of lines in sublocated
end

#build_TokenValue(o) ⇒ Object


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

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


472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
# File 'lib/puppet/pops/model/factory.rb', line 472

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


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

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


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

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

#build_UnaryExpression(o, expr) ⇒ Object


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

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

#captures_restObject

Mark parameter as capturing the rest of arguments


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

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

#contained_current(container) ⇒ Object


1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
# File 'lib/puppet/pops/model/factory.rb', line 1186

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_modelObject


75
76
77
78
# File 'lib/puppet/pops/model/factory.rb', line 75

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


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

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

#dot(r) ⇒ Object


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

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

#eq(r) ⇒ Object


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

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

#f_arithmetic(op, r) ⇒ Object


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

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

#f_build_binary(klazz, left, right) ⇒ Object


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

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

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


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

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

#f_build_body(body) ⇒ Object


347
348
349
350
351
352
353
354
355
356
357
358
# File 'lib/puppet/pops/model/factory.rb', line 347

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


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

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

#f_comparison(op, r) ⇒ Object


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

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

#f_match(op, r) ⇒ Object


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

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

#factory_to_model(value) ⇒ Object


1176
1177
1178
1179
1180
1181
1182
1183
1184
# File 'lib/puppet/pops/model/factory.rb', line 1176

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


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

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.


333
334
335
336
# File 'lib/puppet/pops/model/factory.rb', line 333

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

#infer_FalseClass(o) ⇒ Object


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

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

#infer_Float(o) ⇒ Object


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

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


341
342
343
344
345
# File 'lib/puppet/pops/model/factory.rb', line 341

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


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

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

#infer_NilClass(o) ⇒ Object


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

def infer_NilClass(o)
  @model_class = Nop
end

#infer_Regexp(o) ⇒ Object


312
313
314
315
316
# File 'lib/puppet/pops/model/factory.rb', line 312

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.


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

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.


321
322
323
324
325
326
327
328
329
330
# File 'lib/puppet/pops/model/factory.rb', line 321

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


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

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

#interpolateObject

Polymorphic interpolate


117
118
119
# File 'lib/puppet/pops/model/factory.rb', line 117

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 $


1121
1122
1123
1124
1125
1126
1127
# File 'lib/puppet/pops/model/factory.rb', line 1121

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


1138
1139
1140
1141
1142
1143
1144
# File 'lib/puppet/pops/model/factory.rb', line 1138

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


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

def interpolate_Factory(c)
  self
end

#interpolate_LiteralInteger(c) ⇒ Object


1104
1105
1106
1107
# File 'lib/puppet/pops/model/factory.rb', line 1104

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

#interpolate_NamedAccessExpression(c) ⇒ Object


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

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


1109
1110
1111
# File 'lib/puppet/pops/model/factory.rb', line 1109

def interpolate_Object(c)
  self
end

#interpolate_QualifiedName(c) ⇒ Object


1113
1114
1115
# File 'lib/puppet/pops/model/factory.rb', line 1113

def interpolate_QualifiedName(c)
  self.var
end

#is_interop_rewriteable?(o) ⇒ Boolean


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

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


633
634
635
636
# File 'lib/puppet/pops/model/factory.rb', line 633

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

#lengthObject


662
663
664
# File 'lib/puppet/pops/model/factory.rb', line 662

def length
  @init_hash[KEY_LENGTH]
end

#map_offset(model, locator) ⇒ Object


93
94
95
# File 'lib/puppet/pops/model/factory.rb', line 93

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

#map_offset_Factory(o, locator) ⇒ Object


101
102
103
# File 'lib/puppet/pops/model/factory.rb', line 101

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

#map_offset_Object(o, locator) ⇒ Object


97
98
99
# File 'lib/puppet/pops/model/factory.rb', line 97

def map_offset_Object(o, locator)
  o
end

#map_offset_Positioned(o, locator) ⇒ Object


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

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

#minusObject


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

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

#minus_set(r) ⇒ Object

Assignment -=


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

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

#mne(r) ⇒ Object


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

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

#modelObject Also known as: current


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

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


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

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

#notObject


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

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

#offsetObject


658
659
660
# File 'lib/puppet/pops/model/factory.rb', line 658

def offset
  @init_hash[KEY_OFFSET]
end

#or(r) ⇒ Object


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

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

#parenObject


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

def paren;    f_build_unary(ParenthesizedExpression, self);   end

#plus_set(r) ⇒ Object

Assignment +=


644
645
646
# File 'lib/puppet/pops/model/factory.rb', line 644

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.


668
669
670
671
672
673
674
675
# File 'lib/puppet/pops/model/factory.rb', line 668

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


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

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

#select(*args) ⇒ Object


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

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

#set(r) ⇒ Object

Assignment =


639
640
641
# File 'lib/puppet/pops/model/factory.rb', line 639

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

#textObject


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

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

#to_sObject


1172
1173
1174
# File 'lib/puppet/pops/model/factory.rb', line 1172

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

#type_expr(o) ⇒ Object

Set Expression that should evaluate to the parameter's type


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

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

#unfoldObject


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

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

#varObject


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

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