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



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

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) 



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

def model_class
  @model_class
end

#unfolded ⇒ Object (readonly) 



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

def unfolded
  @unfolded
end

Class Method Details

.APPLICATION(name, parameters, body) ⇒ Object 



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

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

.APPLY(arguments, body) ⇒ Object 



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

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

.APPLY_BLOCK(statements) ⇒ Object 



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

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

.ARGUMENTS(args, arg) ⇒ Object 



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

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 



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

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

.ATTRIBUTES_OP(expr) ⇒ Object 



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

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

.block(*args) ⇒ Object 



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

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



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

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 



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

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)



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

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 



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

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 



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

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

.CASE(test_e, *options) ⇒ Object 



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

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

.COLLECT(type_expr, query_expr, attribute_operations) ⇒ Object 



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

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

.concat(*args) ⇒ Object 



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

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

.DEFINITION(name, parameters, body) ⇒ Object 



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

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

.EPP(parameters, body) ⇒ Object 



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

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 



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

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.



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

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.



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

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

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



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

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

.HASH(entries) ⇒ Object 



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

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

.HASH_UNFOLDED(entries) ⇒ Object 



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

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

.HEREDOC(name, expr) ⇒ Object 



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

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

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



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

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

.IF(test_e, then_e, else_e) ⇒ Object 



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

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

.infer(o) ⇒ Object 



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

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

.KEY_ENTRY(key, val) ⇒ Object 



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

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

.LAMBDA(parameters, body, return_type) ⇒ Object 



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

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

.LIST(entries) ⇒ Object 



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

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

.literal(o) ⇒ Object

Factory starting points



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

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

.MAP(match, value) ⇒ Object 



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

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

.minus(o) ⇒ Object 



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

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) 


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

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

.NAMED_ACCESS(type_name, bodies) ⇒ Object 



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

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

.NODE(hosts, parent, body) ⇒ Object 



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

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

.nop?(o) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

.NUMBER(name_or_numeric) ⇒ Object 



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

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

.PARAM(name, expr = nil) ⇒ Object 



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

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

.PLAN(name, parameters, body) ⇒ Object 



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

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

.PROGRAM(body, definitions, locator) ⇒ Object 



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

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.



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

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



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

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

.QREF(name) ⇒ Object 



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

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

.RENDER_EXPR(expr) ⇒ Object 



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

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

.RENDER_STRING(o) ⇒ Object

TODO_EPP



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

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

.RESERVED(name, future = false) ⇒ Object 



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

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

.RESOURCE(type_name, bodies) ⇒ Object 



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

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

.RESOURCE_BODY(resource_title, attribute_operations) ⇒ Object 



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

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

.RESOURCE_DEFAULTS(type_name, attribute_operations) ⇒ Object 



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

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

.RESOURCE_OVERRIDE(resource_ref, attribute_operations) ⇒ Object 



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

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


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

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.



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

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 



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

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

.STRING(*args) ⇒ Object 



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

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

.string(*args) ⇒ Object 



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

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

.SUBLOCATE(token, expr_factory) ⇒ Object 



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

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 



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

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

.text(o) ⇒ Object 



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

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.



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

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:



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

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 



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

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 



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

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

.unfold(o) ⇒ Object 



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

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

.UNLESS(test_e, then_e, else_e) ⇒ Object 



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

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

.var(o) ⇒ Object 



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

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

.VIRTUAL_QUERY(query_expr) ⇒ Object 



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

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

.WHEN(values_list, block) ⇒ Object 



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

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

Instance Method Details

#%(r) ⇒ Object 



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

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

#*(r) ⇒ Object 



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

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

#+(r) ⇒ Object 



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

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

#-(r) ⇒ Object 



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

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

#/(r) ⇒ Object 



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

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

#<(r) ⇒ Object 



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

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

#<<(r) ⇒ Object 



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

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

#<=(r) ⇒ Object 



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

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

#=~(r) ⇒ Object 



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

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

#>(r) ⇒ Object 



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

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

#>=(r) ⇒ Object 



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

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

#>>(r) ⇒ Object 



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

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

#[](key) ⇒ Object 



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

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

#[]=(key, value) ⇒ Object 



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

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

#access(r) ⇒ Object 



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

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



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

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

#all_factories(&block) ⇒ Object 



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

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 



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

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

#attributes(*args) ⇒ Object 



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

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

#build_AccessExpression(o, left, keys) ⇒ Object 



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

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



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

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 



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

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

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



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

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 



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

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 



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

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 



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

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

#build_BinaryExpression(o, left, right) ⇒ Object 



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

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

#build_BlockExpression(o, args) ⇒ Object 



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

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



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

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 



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

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 



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

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 



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

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

#build_CaseOption(o, value_list, then_expr) ⇒ Object 



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

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 



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

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 



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

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

#build_ConcatenatedString(o, args) ⇒ Object 



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

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 



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

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 



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

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 



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

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:



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

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 



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

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 



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

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

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



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

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 



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

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

#build_LiteralHash(o, keyed_entries, unfolded) ⇒ Object 



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

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

#build_LiteralInteger(o, val, radix) ⇒ Object 



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

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

#build_LiteralList(o, values) ⇒ Object 



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

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

#build_LiteralString(o, value) ⇒ Object 



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

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

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



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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

#build_QualifiedReference(o, name) ⇒ Object 



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

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

#build_QueryExpression(o, expr) ⇒ Object 



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

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

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



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

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

#build_RenderStringExpression(o, string) ⇒ Object 



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

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

#build_ReservedWord(o, name, future) ⇒ Object 



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

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

#build_ResourceBody(o, title_expression, attribute_operations) ⇒ Object 



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

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 



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

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 



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

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 



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

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

#build_SelectorEntry(o, matching, value) ⇒ Object 



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

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

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



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

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

#build_SiteDefinition(o, body) ⇒ Object 



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

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.



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

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 



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

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 



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

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 



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

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 



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

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

#build_UnaryExpression(o, expr) ⇒ Object 



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

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



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

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

#contained_current(container) ⇒ Object 



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

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 



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

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



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

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

#dot(r) ⇒ Object 



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

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

#eq(r) ⇒ Object 



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

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

#f_arithmetic(op, r) ⇒ Object 



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

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

#f_build_binary(klazz, left, right) ⇒ Object 



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

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

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



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

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

#f_build_body(body) ⇒ Object 



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

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



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

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

#f_comparison(op, r) ⇒ Object 



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

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

#f_match(op, r) ⇒ Object 



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

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

#factory_to_model(value) ⇒ Object 



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

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



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

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.



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

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

#infer_FalseClass(o) ⇒ Object 



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

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

#infer_Float(o) ⇒ Object 



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

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



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

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 



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

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

#infer_NilClass(o) ⇒ Object 



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

def infer_NilClass(o)
  @model_class = Nop
end

#infer_Regexp(o) ⇒ Object 



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

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.



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

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.



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

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 



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

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

#interpolate ⇒ Object

Polymorphic interpolate



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

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 $



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

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



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

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 



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

def interpolate_Factory(c)
  self
end

#interpolate_LiteralInteger(c) ⇒ Object 



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

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

#interpolate_NamedAccessExpression(c) ⇒ Object 



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

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 



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

def interpolate_Object(c)
  self
end

#interpolate_QualifiedName(c) ⇒ Object 



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

def interpolate_QualifiedName(c)
  self.var
end

#is_interop_rewriteable?(o) ⇒ Boolean

Returns:

  • (Boolean) 


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

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 



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

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

#length ⇒ Object 



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

def length
  @init_hash[KEY_LENGTH]
end

#map_offset(model, locator) ⇒ Object 



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

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

#map_offset_Factory(o, locator) ⇒ Object 



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

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

#map_offset_Object(o, locator) ⇒ Object 



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

def map_offset_Object(o, locator)
  o
end

#map_offset_Positioned(o, locator) ⇒ Object 



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

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 



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

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

#minus_set(r) ⇒ Object

Assignment -=



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

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

#mne(r) ⇒ Object 



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

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

#model ⇒ Object Also known as: current 



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

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 



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

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

#not ⇒ Object 



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

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

#offset ⇒ Object 



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

def offset
  @init_hash[KEY_OFFSET]
end

#or(r) ⇒ Object 



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

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

#paren ⇒ Object 



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

def paren;    f_build_unary(ParenthesizedExpression, self);   end

#plus_set(r) ⇒ Object

Assignment +=



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

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.



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

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 



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

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

#select(*args) ⇒ Object 



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

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

#set(r) ⇒ Object

Assignment =



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

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

#text ⇒ Object 



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

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

#to_s ⇒ Object 



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

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

#type_expr(o) ⇒ Object

Set Expression that should evaluate to the parameter's type



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

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

#unfold ⇒ Object 



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

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

#var ⇒ Object 



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

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