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')
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



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

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) 



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

def model_class
  @model_class
end

#unfolded ⇒ Object (readonly) 



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

def unfolded
  @unfolded
end

Class Method Details

.APPLICATION(name, parameters, body) ⇒ Object 



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

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

.APPLY(arguments, body) ⇒ Object 



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

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

.APPLY_BLOCK(statements) ⇒ Object 



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

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

.ARGUMENTS(args, arg) ⇒ Object 



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

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 



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

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

.ATTRIBUTES_OP(expr) ⇒ Object 



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

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

.block(*args) ⇒ Object 



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

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



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

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 



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

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

.CALL_NAMED(name, rval_required, argument_list) ⇒ Object 



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

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)



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

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 



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

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

.CASE(test_e, *options) ⇒ Object 



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

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

.COLLECT(type_expr, query_expr, attribute_operations) ⇒ Object 



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

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

.concat(*args) ⇒ Object 



1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
 
# File 'lib/puppet/pops/model/factory.rb', line 1122

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 



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

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

.EPP(parameters, body) ⇒ Object 



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

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 



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

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.



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

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.



764
765
766
 
# File 'lib/puppet/pops/model/factory.rb', line 764

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

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



953
954
955
 
# File 'lib/puppet/pops/model/factory.rb', line 953

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

.HASH(entries) ⇒ Object 



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

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

.HASH_UNFOLDED(entries) ⇒ Object 



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

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

.HEREDOC(name, expr) ⇒ Object 



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

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

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



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

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

.IF(test_e, then_e, else_e) ⇒ Object 



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

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

.infer(o) ⇒ Object 



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

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

.KEY_ENTRY(key, val) ⇒ Object 



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

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

.LAMBDA(parameters, body, return_type) ⇒ Object 



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

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

.LIST(entries) ⇒ Object 



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

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

.literal(o) ⇒ Object

Factory starting points



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

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

.MAP(match, value) ⇒ Object 



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

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

.minus(o) ⇒ Object 



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

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) 


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

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

.NAMED_ACCESS(type_name, bodies) ⇒ Object 



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

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

.NODE(hosts, parent, body) ⇒ Object 



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

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

.nop?(o) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

.NUMBER(name_or_numeric) ⇒ Object 



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

def self.NUMBER(name_or_numeric)
  if n_radix = Utils.to_n_with_radix(name_or_numeric)
    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 



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

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

.PLAN(name, parameters, body) ⇒ Object 



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

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

.PROGRAM(body, definitions, locator) ⇒ Object 



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

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.



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

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
 
# File 'lib/puppet/pops/model/factory.rb', line 821

def self.QNAME_OR_NUMBER(name)
  if n_radix = Utils.to_n_with_radix(name)
    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 



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

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

.RENDER_EXPR(expr) ⇒ Object 



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

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

.RENDER_STRING(o) ⇒ Object

TODO_EPP



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

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

.RESERVED(name, future = false) ⇒ Object 



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

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

.RESOURCE(type_name, bodies) ⇒ Object 



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

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

.RESOURCE_BODY(resource_title, attribute_operations) ⇒ Object 



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

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

.RESOURCE_DEFAULTS(type_name, attribute_operations) ⇒ Object 



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

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

.RESOURCE_OVERRIDE(resource_ref, attribute_operations) ⇒ Object 



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

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



671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
 
# File 'lib/puppet/pops/model/factory.rb', line 671

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.



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

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 



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

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

.STRING(*args) ⇒ Object 



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

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

.string(*args) ⇒ Object 



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

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

.SUBLOCATE(token, expr) ⇒ Object 



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

def self.SUBLOCATE(token, expr)        new(SubLocatedExpression, token, expr);         end

.text(o) ⇒ Object 



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

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

.TEXT(expr) ⇒ Object 



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

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

.transform_calls(expressions) ⇒ Object

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



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
1040
1041
1042
1043
1044
1045
1046
 
# File 'lib/puppet/pops/model/factory.rb', line 1015

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)

Parameters:



1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
 
# File 'lib/puppet/pops/model/factory.rb', line 1050

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 



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

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 



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

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

.unfold(o) ⇒ Object 



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

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

.UNLESS(test_e, then_e, else_e) ⇒ Object 



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

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

.var(o) ⇒ Object 



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

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

.VIRTUAL_QUERY(query_expr) ⇒ Object 



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

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

.WHEN(values_list, block) ⇒ Object 



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

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

Instance Method Details

#%(r) ⇒ Object 



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

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

#*(r) ⇒ Object 



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

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

#+(r) ⇒ Object 



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

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

#-(r) ⇒ Object 



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

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

#/(r) ⇒ Object 



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

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

#<(r) ⇒ Object 



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

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

#<<(r) ⇒ Object 



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

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

#<=(r) ⇒ Object 



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

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

#=~(r) ⇒ Object 



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

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

#>(r) ⇒ Object 



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

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

#>=(r) ⇒ Object 



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

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

#>>(r) ⇒ Object 



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

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

#[](key) ⇒ Object 



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

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

#[]=(key, value) ⇒ Object 



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

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

#access(r) ⇒ Object 



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

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



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

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

#all_factories(&block) ⇒ Object 



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

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 



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

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

#attributes(*args) ⇒ Object 



630
631
632
633
 
# File 'lib/puppet/pops/model/factory.rb', line 630

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

#build_AccessExpression(o, left, keys) ⇒ Object 



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

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



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

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 



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

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

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



106
107
108
109
 
# File 'lib/puppet/pops/model/factory.rb', line 106

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 



111
112
113
114
 
# File 'lib/puppet/pops/model/factory.rb', line 111

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 



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

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 



122
123
124
 
# File 'lib/puppet/pops/model/factory.rb', line 122

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

#build_BinaryExpression(o, left, right) ⇒ Object 



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

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

#build_BlockExpression(o, args) ⇒ Object 



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

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



147
148
149
150
151
 
# File 'lib/puppet/pops/model/factory.rb', line 147

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 



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

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 



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

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 



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

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

#build_CaseOption(o, value_list, then_expr) ⇒ Object 



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

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 



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

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 



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

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

#build_ConcatenatedString(o, args) ⇒ Object 



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

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 



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

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 



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

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 



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

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:



197
198
199
200
 
# File 'lib/puppet/pops/model/factory.rb', line 197

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 



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

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 



212
213
214
215
 
# File 'lib/puppet/pops/model/factory.rb', line 212

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

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



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

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 



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

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

#build_LiteralHash(o, keyed_entries, unfolded) ⇒ Object 



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

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

#build_LiteralInteger(o, val, radix) ⇒ Object 



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

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

#build_LiteralList(o, values) ⇒ Object 



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

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

#build_LiteralString(o, value) ⇒ Object 



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

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

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



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

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 



343
344
345
346
347
348
 
# File 'lib/puppet/pops/model/factory.rb', line 343

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 



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

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 



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

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 



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

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 



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

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 



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

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

#build_QualifiedReference(o, name) ⇒ Object 



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

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

#build_QueryExpression(o, expr) ⇒ Object 



445
446
447
 
# File 'lib/puppet/pops/model/factory.rb', line 445

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

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



394
395
396
397
 
# File 'lib/puppet/pops/model/factory.rb', line 394

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

#build_RenderStringExpression(o, string) ⇒ Object 



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

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

#build_ReservedWord(o, name, future) ⇒ Object 



207
208
209
210
 
# File 'lib/puppet/pops/model/factory.rb', line 207

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

#build_ResourceBody(o, title_expression, attribute_operations) ⇒ Object 



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

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 



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

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 



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

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 



202
203
204
205
 
# File 'lib/puppet/pops/model/factory.rb', line 202

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

#build_SelectorEntry(o, matching, value) ⇒ Object 



440
441
442
443
 
# File 'lib/puppet/pops/model/factory.rb', line 440

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

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



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

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

#build_SiteDefinition(o, body) ⇒ Object 



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

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.



428
429
430
431
432
433
434
435
436
437
438
 
# File 'lib/puppet/pops/model/factory.rb', line 428

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
  # Index is held in sublocator's parent locator - needed to be able to reconstruct
  @init_hash['line_offsets'] = locator.locator.line_index
end

#build_TokenValue(o) ⇒ Object 



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

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 



449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
 
# File 'lib/puppet/pops/model/factory.rb', line 449

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 



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

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 



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

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

#build_UnaryExpression(o, expr) ⇒ Object 



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

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



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

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

#contained_current(container) ⇒ Object 



1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
 
# File 'lib/puppet/pops/model/factory.rb', line 1150

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 



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

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



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

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

#dot(r) ⇒ Object 



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

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

#eq(r) ⇒ Object 



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

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

#f_arithmetic(op, r) ⇒ Object 



526
527
528
 
# File 'lib/puppet/pops/model/factory.rb', line 526

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

#f_build_binary(klazz, left, right) ⇒ Object 



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

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

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



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

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

#f_build_body(body) ⇒ Object 



323
324
325
326
327
328
329
330
331
332
333
334
 
# File 'lib/puppet/pops/model/factory.rb', line 323

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



514
515
516
 
# File 'lib/puppet/pops/model/factory.rb', line 514

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

#f_comparison(op, r) ⇒ Object 



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

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

#f_match(op, r) ⇒ Object 



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

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

#factory_to_model(value) ⇒ Object 



1140
1141
1142
1143
1144
1145
1146
1147
1148
 
# File 'lib/puppet/pops/model/factory.rb', line 1140

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



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

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.



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

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

#infer_FalseClass(o) ⇒ Object 



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

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

#infer_Float(o) ⇒ Object 



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

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



317
318
319
320
321
 
# File 'lib/puppet/pops/model/factory.rb', line 317

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 



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

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

#infer_NilClass(o) ⇒ Object 



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

def infer_NilClass(o)
  @model_class = Nop
end

#infer_Regexp(o) ⇒ Object 



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

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.



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

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.



297
298
299
300
301
302
303
304
305
306
 
# File 'lib/puppet/pops/model/factory.rb', line 297

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 



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

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

#interpolate ⇒ Object

Polymorphic interpolate



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

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 $



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

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



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

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 



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

def interpolate_Factory(c)
  self
end

#interpolate_LiteralInteger(c) ⇒ Object 



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

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

#interpolate_NamedAccessExpression(c) ⇒ Object 



1093
1094
1095
1096
1097
1098
1099
 
# File 'lib/puppet/pops/model/factory.rb', line 1093

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 



1073
1074
1075
 
# File 'lib/puppet/pops/model/factory.rb', line 1073

def interpolate_Object(c)
  self
end

#interpolate_QualifiedName(c) ⇒ Object 



1077
1078
1079
 
# File 'lib/puppet/pops/model/factory.rb', line 1077

def interpolate_QualifiedName(c)
  self.var
end

#is_interop_rewriteable?(o) ⇒ Boolean

Returns:

  • (Boolean) 


1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
 
# File 'lib/puppet/pops/model/factory.rb', line 1110

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 



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

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

#length ⇒ Object 



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

def length
  @init_hash[KEY_LENGTH]
end

#minus ⇒ Object 



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

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

#minus_set(r) ⇒ Object

Assignment -=



626
627
628
 
# File 'lib/puppet/pops/model/factory.rb', line 626

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

#mne(r) ⇒ Object 



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

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

#model ⇒ Object Also known as: current 



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

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 



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

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

#not ⇒ Object 



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

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

#offset ⇒ Object 



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

def offset
  @init_hash[KEY_OFFSET]
end

#or(r) ⇒ Object 



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

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

#paren ⇒ Object 



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

def paren;    f_build_unary(ParenthesizedExpression, self);   end

#plus_set(r) ⇒ Object

Assignment +=



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

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.



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

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 



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

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

#select(*args) ⇒ Object 



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

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

#set(r) ⇒ Object

Assignment =



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

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

#text ⇒ Object 



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

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

#to_s ⇒ Object 



1136
1137
1138
 
# File 'lib/puppet/pops/model/factory.rb', line 1136

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

#type_expr(o) ⇒ Object

Set Expression that should evaluate to the parameter’s type



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

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

#unfold ⇒ Object 



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

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

#var ⇒ Object 



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

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