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

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

Defined Under Namespace

Classes: ArgsToNonCallError

Constant Summary collapse

KEY_LENGTH =

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

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

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

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

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(o, *args) ⇒ Factory

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



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

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

Instance Attribute Details

#model_class ⇒ Object (readonly) 



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

def model_class
  @model_class
end

Class Method Details

.APPLICATION(name, parameters, body) ⇒ Object 



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

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

.ATTRIBUTE_OP(name, op, expr) ⇒ Object 



824
825
826
 
# File 'lib/puppet/pops/model/factory.rb', line 824

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

.ATTRIBUTES_OP(expr) ⇒ Object 



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

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

.block(*args) ⇒ Object 



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

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



874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
 
# File 'lib/puppet/pops/model/factory.rb', line 874

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 



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

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

.CALL_NAMED(name, rval_required, argument_list) ⇒ Object 



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

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

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

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



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

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

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



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

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

.CASE(test_e, *options) ⇒ Object 



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

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

.COLLECT(type_expr, query_expr, attribute_operations) ⇒ Object 



845
846
847
 
# File 'lib/puppet/pops/model/factory.rb', line 845

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

.concat(*args) ⇒ Object 



1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
 
# File 'lib/puppet/pops/model/factory.rb', line 1077

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 #{e.class}"
    end
  end
  infer(result)
end

.DEFINITION(name, parameters, body) ⇒ Object 



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

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

.EPP(parameters, body) ⇒ Object 



761
762
763
764
765
766
767
768
769
770
 
# File 'lib/puppet/pops/model/factory.rb', line 761

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 



820
821
822
 
# File 'lib/puppet/pops/model/factory.rb', line 820

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.



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

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.



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

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

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



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

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

.HASH(entries) ⇒ Object 



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

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

.HEREDOC(name, expr) ⇒ Object 



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

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

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



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

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

.IF(test_e, then_e, else_e) ⇒ Object 



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

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

.infer(o) ⇒ Object 



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

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

.KEY_ENTRY(key, val) ⇒ Object 



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

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

.LAMBDA(parameters, body, return_type) ⇒ Object 



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

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

.LIST(entries) ⇒ Object 



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

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

.literal(o) ⇒ Object

Factory starting points



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

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

.MAP(match, value) ⇒ Object 



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

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

.minus(o) ⇒ Object 



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

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) 


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

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

.NAMED_ACCESS(type_name, bodies) ⇒ Object 



849
850
851
 
# File 'lib/puppet/pops/model/factory.rb', line 849

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

.NODE(hosts, parent, body) ⇒ Object 



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

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

.nop?(o) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

.NUMBER(name_or_numeric) ⇒ Object 



783
784
785
786
787
788
789
790
791
792
793
794
795
 
# File 'lib/puppet/pops/model/factory.rb', line 783

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
    raise ArgumentError, "Internal Error, NUMBER token does not contain a valid number, #{name_or_numeric}"
  end
end

.PARAM(name, expr = nil) ⇒ Object 



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

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

.PROGRAM(body, definitions, locator) ⇒ Object 



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

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.



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

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



799
800
801
802
803
804
805
806
807
808
809
810
 
# File 'lib/puppet/pops/model/factory.rb', line 799

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 



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

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

.RENDER_EXPR(expr) ⇒ Object 



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

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

.RENDER_STRING(o) ⇒ Object

TODO_EPP



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

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

.RESERVED(name, future = false) ⇒ Object 



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

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

.RESOURCE(type_name, bodies) ⇒ Object 



853
854
855
 
# File 'lib/puppet/pops/model/factory.rb', line 853

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

.RESOURCE_BODY(resource_title, attribute_operations) ⇒ Object 



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

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

.RESOURCE_DEFAULTS(type_name, attribute_operations) ⇒ Object 



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

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

.RESOURCE_OVERRIDE(resource_ref, attribute_operations) ⇒ Object 



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

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



653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
 
# File 'lib/puppet/pops/model/factory.rb', line 653

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.



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

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 



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

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

.STRING(*args) ⇒ Object 



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

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

.string(*args) ⇒ Object 



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

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

.SUBLOCATE(token, expr) ⇒ Object 



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

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

.TEXT(expr) ⇒ Object 



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

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

.text(o) ⇒ Object 



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

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.



970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
 
# File 'lib/puppet/pops/model/factory.rb', line 970

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:



1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
 
# File 'lib/puppet/pops/model/factory.rb', line 1005

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 



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

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 



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

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

.unfold(o) ⇒ Object 



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

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

.UNLESS(test_e, then_e, else_e) ⇒ Object 



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

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

.var(o) ⇒ Object 



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

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

.VIRTUAL_QUERY(query_expr) ⇒ Object 



816
817
818
 
# File 'lib/puppet/pops/model/factory.rb', line 816

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

.WHEN(values_list, block) ⇒ Object 



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

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

Instance Method Details

#%(r) ⇒ Object 



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

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

#*(r) ⇒ Object 



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

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

#+(r) ⇒ Object 



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

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

#-(r) ⇒ Object 



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

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

#/(r) ⇒ Object 



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

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

#<(r) ⇒ Object 



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

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

#<<(r) ⇒ Object 



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

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

#<=(r) ⇒ Object 



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

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

#=~(r) ⇒ Object 



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

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

#>(r) ⇒ Object 



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

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

#>=(r) ⇒ Object 



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

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

#>>(r) ⇒ Object 



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

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

#[](key) ⇒ Object 



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

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

#[]=(key, value) ⇒ Object 



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

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

#access(r) ⇒ Object 



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

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



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

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

#all_factories(&block) ⇒ Object 



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

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

#and(r) ⇒ Object 



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

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

#attributes(*args) ⇒ Object 



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

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

#build_AccessExpression(o, left, keys) ⇒ Object 



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

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

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

Building of Model classes



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

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

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



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

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

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



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

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

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



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

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

#build_AttributesOperation(o, value) ⇒ Object 



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

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

#build_BinaryExpression(o, left, right) ⇒ Object 



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

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

#build_BlockExpression(o, args) ⇒ Object 



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

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

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

Parameters:

  • rval_required (Boolean) —

    if the call must produce a value



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

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

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



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

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

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



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

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

#build_CaseExpression(o, test, args) ⇒ Object 



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

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

#build_CaseOption(o, value_list, then_expr) ⇒ Object 



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

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

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



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

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

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



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

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

#build_ConcatenatedString(o, args) ⇒ Object 



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

def build_ConcatenatedString(o, args)
  @init_hash['segments'] = args
end

#build_EppExpression(o, parameters_specified, body) ⇒ Object 



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

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

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



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

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 



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

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:



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

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 



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

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 



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

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

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



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

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 



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

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

#build_LiteralHash(o, keyed_entries) ⇒ Object 



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

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

#build_LiteralInteger(o, val, radix) ⇒ Object 



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

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

#build_LiteralList(o, values) ⇒ Object 



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

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

#build_LiteralString(o, value) ⇒ Object 



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

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

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



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

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 



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

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 



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

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 



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

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

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



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

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 



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

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

#build_QualifiedReference(o, name) ⇒ Object 



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

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

#build_QueryExpression(o, expr) ⇒ Object 



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

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

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



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

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

#build_RenderStringExpression(o, string) ⇒ Object 



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

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

#build_ReservedWord(o, name, future) ⇒ Object 



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

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

#build_ResourceBody(o, title_expression, attribute_operations) ⇒ Object 



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

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 



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

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 



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

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 



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

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

#build_SelectorEntry(o, matching, value) ⇒ Object 



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

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

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



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

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

#build_SiteDefinition(o, body) ⇒ Object 



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

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.



412
413
414
415
416
417
418
419
420
421
422
 
# File 'lib/puppet/pops/model/factory.rb', line 412

def build_SubLocatedExpression(o, token, expression)
  @init_hash[KEY_EXPR] = expression
  @init_hash[KEY_OFFSET] = token.offset
  @init_hash[KEY_LENGTH] =  token.length
  locator = token.locator
  @init_hash[KEY_LOCATOR] = locator
  @init_hash['leading_line_count'] = locator.leading_line_count
  @init_hash['leading_line_offset'] = locator.leading_line_offset
  # Index is held in sublocator's parent locator - needed to be able to reconstruct
  @init_hash['line_offsets'] = locator.locator.line_index
end

#build_TokenValue(o) ⇒ Object 



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

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 



433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
 
# File 'lib/puppet/pops/model/factory.rb', line 433

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']
    unless parent['cased_value'] == 'Object'
      hash['entries'] << Factory.KEY_ENTRY(Factory.QNAME('parent'), parent)
    end
    type_expr = Factory.QREF('Object').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 



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

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 



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

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

#build_UnaryExpression(o, expr) ⇒ Object 



476
477
478
 
# File 'lib/puppet/pops/model/factory.rb', line 476

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



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

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

#contained_current(container) ⇒ Object 



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

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

#create_model ⇒ Object 



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

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

#default(r) ⇒ Object

For CaseExpression, setting the default for an already build CaseExpression



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

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

#dot(r) ⇒ Object 



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

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

#eq(r) ⇒ Object 



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

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

#f_arithmetic(op, r) ⇒ Object 



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

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

#f_build_binary(klazz, left, right) ⇒ Object 



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

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

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



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

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

#f_build_body(body) ⇒ Object 



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

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



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

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

#f_comparison(op, r) ⇒ Object 



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

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

#f_match(op, r) ⇒ Object 



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

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

#factory_to_model(value) ⇒ Object 



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

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



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

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.



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

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

#infer_FalseClass(o) ⇒ Object 



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

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

#infer_Float(o) ⇒ Object 



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

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



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

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)) }
end

#infer_Integer(o) ⇒ Object 



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

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

#infer_NilClass(o) ⇒ Object 



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

def infer_NilClass(o)
  @model_class = Nop
end

#infer_Regexp(o) ⇒ Object 



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

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.



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

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.



290
291
292
293
294
295
296
297
298
299
 
# File 'lib/puppet/pops/model/factory.rb', line 290

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 



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

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

#interpolate ⇒ Object

Polymorphic interpolate



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

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

#interpolate_AccessExpression(c) ⇒ Object

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



1040
1041
1042
1043
1044
1045
1046
 
# File 'lib/puppet/pops/model/factory.rb', line 1040

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



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

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 



1019
1020
1021
 
# File 'lib/puppet/pops/model/factory.rb', line 1019

def interpolate_Factory(c)
  self
end

#interpolate_LiteralInteger(c) ⇒ Object 



1023
1024
1025
1026
 
# File 'lib/puppet/pops/model/factory.rb', line 1023

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

#interpolate_NamedAccessExpression(c) ⇒ Object 



1048
1049
1050
1051
1052
1053
1054
 
# File 'lib/puppet/pops/model/factory.rb', line 1048

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 



1028
1029
1030
 
# File 'lib/puppet/pops/model/factory.rb', line 1028

def interpolate_Object(c)
  self
end

#interpolate_QualifiedName(c) ⇒ Object 



1032
1033
1034
 
# File 'lib/puppet/pops/model/factory.rb', line 1032

def interpolate_QualifiedName(c)
  self.var
end

#is_interop_rewriteable?(o) ⇒ Boolean

Returns:

  • (Boolean) 


1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
 
# File 'lib/puppet/pops/model/factory.rb', line 1065

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 



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

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

#length ⇒ Object 



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

def length
  @init_hash[KEY_LENGTH]
end

#minus ⇒ Object 



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

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

#minus_set(r) ⇒ Object

Assignment -=



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

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

#mne(r) ⇒ Object 



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

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

#model ⇒ Object Also known as: current 



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

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

#ne(r) ⇒ Object 



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

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

#not ⇒ Object 



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

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

#offset ⇒ Object 



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

def offset
  @init_hash[KEY_OFFSET]
end

#or(r) ⇒ Object 



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

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

#paren ⇒ Object 



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

def paren;    f_build_unary(ParenthesizedExpression, self);   end

#plus_set(r) ⇒ Object

Assignment +=



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

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.



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

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 



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

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

#select(*args) ⇒ Object 



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

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

#set(r) ⇒ Object

Assignment =



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

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

#text ⇒ Object 



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

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

#to_s ⇒ Object 



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

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

#type_expr(o) ⇒ Object

Set Expression that should evaluate to the parameter’s type



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

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

#unfold ⇒ Object 



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

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

#var ⇒ Object 



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

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