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_class ⇒ Object (readonly) 



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

def model_class
  @model_class
end

#unfolded ⇒ Object (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 



971
972
973
 
# File 'lib/puppet/pops/model/factory.rb', line 971

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

.APPLY(arguments, body) ⇒ Object 



979
980
981
 
# File 'lib/puppet/pops/model/factory.rb', line 979

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

.APPLY_BLOCK(statements) ⇒ Object 



983
984
985
 
# File 'lib/puppet/pops/model/factory.rb', line 983

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

.ARGUMENTS(args, arg) ⇒ Object 



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

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 



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

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

.ATTRIBUTES_OP(expr) ⇒ Object 



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

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



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

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 



908
909
910
 
# File 'lib/puppet/pops/model/factory.rb', line 908

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

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

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



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

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

.CALL_NAMED(name, rval_required, argument_list) ⇒ Object 



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

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

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



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

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 



912
913
914
 
# File 'lib/puppet/pops/model/factory.rb', line 912

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

.concat(*args) ⇒ Object 



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

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 



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

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 



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

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 



987
988
989
 
# File 'lib/puppet/pops/model/factory.rb', line 987

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 



959
960
961
 
# File 'lib/puppet/pops/model/factory.rb', line 959

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 



991
992
993
 
# File 'lib/puppet/pops/model/factory.rb', line 991

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

Returns:

  • (Boolean) 


1034
1035
1036
 
# File 'lib/puppet/pops/model/factory.rb', line 1034

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

.NAMED_ACCESS(type_name, bodies) ⇒ Object 



916
917
918
 
# File 'lib/puppet/pops/model/factory.rb', line 916

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

Returns:

  • (Boolean) 


1007
1008
1009
 
# File 'lib/puppet/pops/model/factory.rb', line 1007

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

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 



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 



975
976
977
 
# File 'lib/puppet/pops/model/factory.rb', line 975

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

.PROGRAM(body, definitions, locator) ⇒ Object 



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

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



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

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 



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

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 



920
921
922
 
# File 'lib/puppet/pops/model/factory.rb', line 920

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

.RESOURCE_BODY(resource_title, attribute_operations) ⇒ Object 



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

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

.RESOURCE_DEFAULTS(type_name, attribute_operations) ⇒ Object 



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

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

.RESOURCE_OVERRIDE(resource_ref, attribute_operations) ⇒ Object 



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

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 



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

def self.STRING(*args);                new(ConcatenatedString, args);                  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

.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.



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

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:



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

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 



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

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 



1003
1004
1005
 
# File 'lib/puppet/pops/model/factory.rb', line 1003

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 



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

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

Parameters:

  • rval_required (Boolean) —

    if the call must produce a value



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.

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:



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_rest ⇒ Object

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 



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

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 



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 



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

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

#interpolate ⇒ Object

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 $



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

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



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

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 



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

def interpolate_Factory(c)
  self
end

#interpolate_LiteralInteger(c) ⇒ Object 



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

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

#interpolate_NamedAccessExpression(c) ⇒ Object 



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

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 



1107
1108
1109
 
# File 'lib/puppet/pops/model/factory.rb', line 1107

def interpolate_Object(c)
  self
end

#interpolate_QualifiedName(c) ⇒ Object 



1111
1112
1113
 
# File 'lib/puppet/pops/model/factory.rb', line 1111

def interpolate_QualifiedName(c)
  self.var
end

#is_interop_rewriteable?(o) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#length ⇒ Object 



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

#minus ⇒ Object 



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

#model ⇒ Object 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

#not ⇒ Object 



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

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

#offset ⇒ Object 



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

#paren ⇒ Object 



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

#text ⇒ Object 



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

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

#to_s ⇒ Object 



1170
1171
1172
 
# File 'lib/puppet/pops/model/factory.rb', line 1170

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

#unfold ⇒ Object 



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

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

#var ⇒ Object 



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

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