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

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

Overview

TODO:

All those uppercase methods … they look bad in one way, but stand out nicely in the grammar… decide if they should change into lower case names (some of the are lower case)…

Factory is a helper class that makes construction of a Pops Model much more convenient. It can be viewed as a small internal DSL for model constructions. For usage see tests using the factory.

Constant Summary collapse

Model = 
Puppet::Pops::Model
@@build_visitor =

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

Puppet::Pops::Visitor.new(self, "build")

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(popsobj, *args) ⇒ Factory

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



21
22
23
 
# File 'lib/puppet/pops/model/factory.rb', line 21

def initialize popsobj, *args
  @current = to_ops(popsobj, *args)
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(meth, *args, &block) ⇒ Object

Catch all delegation to current



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

def method_missing(meth, *args, &block)
  if current.respond_to?(meth)
    current.send(meth, *args, &block)
  else
    super
  end
end

Instance Attribute Details

#current ⇒ Object Also known as: model 



12
13
14
 
# File 'lib/puppet/pops/model/factory.rb', line 12

def current
  @current
end

Class Method Details

.ATTR(name, type_expr = nil) ⇒ Object 



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

def self.ATTR(name, type_expr=nil);    new(Model::CreateAttributeExpression, name, type_expr); end

.ATTRIBUTE_OP(name, op, expr) ⇒ Object 



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

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

.block(*args) ⇒ Object 



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

def self.block(*args);                 new(Model::BlockExpression, *args);                     end

.block_or_expression(*args) ⇒ Object

Builds a BlockExpression if args size > 1, else the single expression/value in args



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

def self.block_or_expression(*args)
  if args.size > 1
    new(Model::BlockExpression, *args)
  else
    new(args[0])
  end
end

.CALL_METHOD(functor, argument_list) ⇒ Object 



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

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

.CALL_NAMED(name, rval_required, argument_list) ⇒ Object 



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

def self.CALL_NAMED(name, rval_required, argument_list)
  unless name.kind_of?(Model::PopsObject)
    name = Puppet::Pops::Model::Factory.fqn(name) unless name.is_a?(Puppet::Pops::Model::Factory)
  end
  new(Model::CallNamedFunctionExpression, name, rval_required, *argument_list)
end

.CASE(test_e, *options) ⇒ Object 



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

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

.COLLECT(type_expr, query_expr, attribute_operations) ⇒ Object 



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

def self.COLLECT(type_expr, query_expr, attribute_operations)
  new(Model::CollectExpression, Puppet::Pops::Model::Factory.fqr(type_expr), query_expr, attribute_operations)
end

.DEFINITION(name, parameters, body) ⇒ Object 



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

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

.ENUM(*args) ⇒ Object 



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

def self.ENUM(*args);                  new(Model::CreateEnumExpression, *args);                end

.EXPORTED_QUERY(query_expr) ⇒ Object 



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

def self.EXPORTED_QUERY(query_expr)
  new(Model::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.



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

def self.fqn(o)
  o = o.current if o.is_a?(Puppet::Pops::Model::Factory)
  o = new(Model::QualifiedName, o) unless o.is_a? Model::QualifiedName
  o
end

.fqr(o) ⇒ Object

Creates a QualifiedName representation of o, unless o already represents a QualifiedName in which case it is returned.



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

def self.fqr(o)
  o = o.current if o.is_a?(Puppet::Pops::Model::Factory)
  o = new(Model::QualifiedReference, o) unless o.is_a? Model::QualifiedReference
  o
end

.HASH(entries) ⇒ Object 



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

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

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



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

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

.IF(test_e, then_e, else_e) ⇒ Object 



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

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

.IMPORT(files) ⇒ Object 



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

def self.IMPORT(files)
  new(Model::ImportExpression, files)
end

.INSTANCE(type_name, name_expressions) ⇒ Object

Used by regular grammar, egrammar creates an AccessExpression instead, and evaluation determines if access is to instances or something else.



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

def self.INSTANCE(type_name, name_expressions)
  new(Model::InstanceReferences, type_name, name_expressions)
end

.KEY_ENTRY(key, val) ⇒ Object 



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

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

.LAMBDA(parameters, body) ⇒ Object 



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

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

.LIST(entries) ⇒ Object 



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

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

.literal(o) ⇒ Object

Factory starting points



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

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

.MAP(match, value) ⇒ Object 



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

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

.minus(o) ⇒ Object 



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

def self.minus(o);                     new(o).minus;                                           end

.NAMED_ACCESS(type_name, bodies) ⇒ Object 



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

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

.NODE(hosts, parent, body) ⇒ Object 



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

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

.nop?(o) ⇒ Boolean

Returns:

  • (Boolean) 


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

def self.nop? o
  o.nil? || o.is_a?(Puppet::Pops::Model::Nop)
end

.PARAM(name, expr = nil) ⇒ Object 



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

def self.PARAM(name, expr=nil);        new(Model::Parameter, name, expr);                      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.



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

def self.QNAME(name)
  new(Model::QualifiedName, name)
end

.QNAME_OR_NUMBER(name) ⇒ Object

Convert input string to either a qualified name, or a LiteralNumber with radix



559
560
561
562
563
564
565
 
# File 'lib/puppet/pops/model/factory.rb', line 559

def self.QNAME_OR_NUMBER(name)
  if n_radix = Puppet::Pops::Utils.to_n_with_radix(name)
    new(Model::LiteralNumber, *n_radix)
  else
    new(Model::QualifiedName, name)
  end
end

.QREF(name) ⇒ Object 



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

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

.RESOURCE(type_name, bodies) ⇒ Object 



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

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

.RESOURCE_BODY(resource_title, attribute_operations) ⇒ Object 



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

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

.RESOURCE_DEFAULTS(type_name, attribute_operations) ⇒ Object 



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

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

.RESOURCE_OVERRIDE(resource_ref, attribute_operations) ⇒ Object 



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

def self.RESOURCE_OVERRIDE(resource_ref, attribute_operations)
  new(Model::ResourceOverrideExpression, resource_ref, attribute_operations)
end

.resource_shape(expr) ⇒ Object

Returns symbolic information about an expected share 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



473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
 
# File 'lib/puppet/pops/model/factory.rb', line 473

def self.resource_shape(expr)
  expr = expr.current if expr.is_a?(Puppet::Pops::Model::Factory)
  case expr
  when Model::QualifiedName
    :resource
  when Model::QualifiedReference
    :defaults
  when Model::AccessExpression
    :override
  when 'class'
    :class
  else
    :error
  end
end

.string(*args) ⇒ Object 



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

def self.string(*args);                new(Model::ConcatenatedString, *args);                  end

.TEXT(expr) ⇒ Object 



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

def self.TEXT(expr)
  new(Model::TextExpression, expr)
end

.text(o) ⇒ Object 



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

def self.text(o);                      new(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. Also transforms a “call” to import into an ImportExpression.



657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
 
# File 'lib/puppet/pops/model/factory.rb', line 657

def self.transform_calls(expressions)
  expressions.reduce([]) do |memo, expr|
    expr = expr.current if expr.is_a?(Puppet::Pops::Model::Factory)
    name = memo[-1]
    if name.is_a? Model::QualifiedName
      if name.value() == 'import'
        memo[-1] = Puppet::Pops::Model::Factory.IMPORT(expr.is_a?(Array) ? expr : [expr])
      else
        memo[-1] = Puppet::Pops::Model::Factory.CALL_NAMED(name, false, expr.is_a?(Array) ? expr : [expr])
        if expr.is_a?(Model::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
      end
    else
      memo << expr
      if expr.is_a?(Model::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

.TYPE(name, super_name = nil) ⇒ Object 



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

def self.TYPE(name, super_name=nil);   new(Model::CreateTypeExpression, name, super_name);     end

.UNLESS(test_e, then_e, else_e) ⇒ Object 



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

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

.var(o) ⇒ Object 



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

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

.VIRTUAL_QUERY(query_expr) ⇒ Object 



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

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

.WHEN(values_list, block) ⇒ Object 



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

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

Instance Method Details

#%(r) ⇒ Object 



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

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

#*(r) ⇒ Object 



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

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

#+(r) ⇒ Object 



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

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

#-(r) ⇒ Object 



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

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

#/(r) ⇒ Object 



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

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

#<(r) ⇒ Object 



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

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

#<<(r) ⇒ Object 



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

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

#<=(r) ⇒ Object 



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

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

#==(r) ⇒ Object 



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

def == r;     f_comparison(:==, r);                                     end

#=~(r) ⇒ Object 



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

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

#>(r) ⇒ Object 



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

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

#>=(r) ⇒ Object 



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

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

#>>(r) ⇒ Object 



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

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

#[](*r) ⇒ Object 



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

def [](*r);   f_build_vararg(Model::AccessExpression, current, *r);     end

#and(r) ⇒ Object 



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

def and(r)    f_build_binary(Model::AndExpression, current, r);         end

#attributes(*args) ⇒ Object 



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

def attributes(*args)
  args.each {|a| current.addAttributes(build(a)) }
  self
end

#build(o, *args) ⇒ Object

Polymorphic build



26
27
28
29
30
31
32
33
 
# File 'lib/puppet/pops/model/factory.rb', line 26

def build(o, *args)
  begin
    @@build_visitor.visit_this(self, o, *args)
  rescue =>e
    # require 'debugger'; debugger # enable this when in trouble...
    raise e
  end
end

#build_AccessExpression(o, left, *keys) ⇒ Object 



54
55
56
57
58
 
# File 'lib/puppet/pops/model/factory.rb', line 54

def build_AccessExpression(o, left, *keys)
  o.left_expr = to_ops(left)
  keys.each {|expr| o.addKeys(to_ops(expr)) }
  o
end

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

Building of Model classes



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

def build_ArithmeticExpression(o, op, a, b)
  o.operator = op
  build_BinaryExpression(o, a, b)
end

#build_Array(o) ⇒ Object

Creates a LiteralList instruction from an Array, where the entries are built.



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

def build_Array(o)
  x = Model::LiteralList.new
  o.each { |v| x.addValues(build(v)) }
  x
end

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



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

def build_AssignmentExpression(o, op, a, b)
  o.operator = op
  build_BinaryExpression(o, a, b)
end

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



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

def build_AttributeOperation(o, name, op, value)
  o.operator = op
  o.attribute_name = name.to_s # BOOLEAN is allowed in the grammar
  o.value_expr = build(value)
  o
end

#build_BinaryExpression(o, left, right) ⇒ Object 



60
61
62
63
64
 
# File 'lib/puppet/pops/model/factory.rb', line 60

def build_BinaryExpression(o, left, right)
  o.left_expr = to_ops(left)
  o.right_expr = to_ops(right)
  o
end

#build_BlockExpression(o, *args) ⇒ Object 



66
67
68
69
 
# File 'lib/puppet/pops/model/factory.rb', line 66

def build_BlockExpression(o, *args)
  args.each {|expr| o.addStatements(to_ops(expr)) }
  o
end

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

Parameters:

  • rval_required (Boolean) —

    if the call must produce a value



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

def build_CallExpression(o, functor, rval_required, *args)
  o.functor_expr = to_ops(functor)
  o.rval_required = rval_required
  args.each {|x| o.addArguments(to_ops(x)) }
  o
end

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

# @param rval_required [Boolean] if the call must produce a value

def build_CallNamedFunctionExpression(o, name, rval_required, *args)
  build_CallExpression(o, name, rval_required, *args)
  o.functor_expr = build(name)
  o.rval_required = rval_required
  args.each {|x| o.addArguments(build(x)) }
  o
end



782
783
784
785
786
 
# File 'lib/puppet/pops/model/factory.rb', line 782

def build_CallMethodExpression(o, functor, rval_required, lambda, *args)
  build_CallExpression(o, functor, rval_required, *args)
  o.lambda = lambda
  o
end

#build_CaseExpression(o, test, *args) ⇒ Object 



788
789
790
791
792
 
# File 'lib/puppet/pops/model/factory.rb', line 788

def build_CaseExpression(o, test, *args)
  o.test = build(test)
  args.each {|opt| o.addOptions(build(opt)) }
  o
end

#build_CaseOption(o, value_list, then_expr) ⇒ Object 



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

def build_CaseOption(o, value_list, then_expr)
  value_list = [value_list] unless value_list.is_a? Array
  value_list.each { |v| o.addValues(build(v)) }
  b = f_build_body(then_expr)
  o.then_expr = to_ops(b) if b
  o
end

#build_Class(o, *args) ⇒ Object

Build a Class by creating an instance of it, and then calling build on the created instance with the given arguments



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

def build_Class(o, *args)
  build(o.new(), *args)
end

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



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

def build_CollectExpression(o, type_expr, query_expr, attribute_operations)
  o.type_expr = to_ops(type_expr)
  o.query = build(query_expr)
  attribute_operations.each {|op| o.addOperations(build(op)) }
  o
end

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



78
79
80
81
 
# File 'lib/puppet/pops/model/factory.rb', line 78

def build_ComparisonExpression(o, op, a, b)
  o.operator = op
  build_BinaryExpression(o, a, b)
end

#build_ConcatenatedString(o, *args) ⇒ Object 



83
84
85
86
 
# File 'lib/puppet/pops/model/factory.rb', line 83

def build_ConcatenatedString(o, *args)
  args.each {|expr| o.addSegments(build(expr)) }
  o
end

#build_CreateAttributeExpression(o, name, datatype_expr) ⇒ Object 



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

def build_CreateAttributeExpression(o, name, datatype_expr)
  o.name = name
  o.type = to_ops(datatype_expr)
  o
end

#build_CreateEnumExpression(o, *args) ⇒ Object 



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

def build_CreateEnumExpression(o, *args)
  o.name = args.slice(0) if args.size == 2
  o.values = build(args.last)
  o
end

#build_CreateTypeExpression(o, name, super_name = nil) ⇒ Object 



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

def build_CreateTypeExpression(o, name, super_name = nil)
  o.name = name
  o.super_name = super_name
  o
end

#build_Definition(o, parameters, body) ⇒ Object 



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

def build_Definition(o, parameters, body)
  parameters.each {|p| o.addParameters(build(p)) }
  b = f_build_body(body)
  o.body = b.current if b
  o
end

#build_Factory(o) ⇒ Object

If building a factory, simply unwrap the model oject contained in the factory.



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

def build_Factory(o)
  o.current
end

#build_FalseClass(o) ⇒ Object 



707
708
709
710
711
 
# File 'lib/puppet/pops/model/factory.rb', line 707

def build_FalseClass(o)
  x = Model::LiteralBoolean.new
  x.value = o
  x
end

#build_Fixnum(o) ⇒ Object 



713
714
715
716
717
 
# File 'lib/puppet/pops/model/factory.rb', line 713

def build_Fixnum(o)
  x = Model::LiteralNumber.new
  x.value = o;
  x
end

#build_Float(o) ⇒ Object 



719
720
721
722
723
 
# File 'lib/puppet/pops/model/factory.rb', line 719

def build_Float(o)
  x = Model::LiteralNumber.new
  x.value = o;
  x
end

#build_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



759
760
761
762
763
 
# File 'lib/puppet/pops/model/factory.rb', line 759

def build_Hash(o)
  x = Model::LiteralHash.new
  (o.sort_by {|k,v| k.to_s}).each {|k,v| x.addEntries(build(Model::KeyedEntry.new, k, v)) }
  x
end

#build_HostClassDefinition(o, name, parameters, parent_class_name, body) ⇒ Model::HostClassDefinition

Returns configured from the parameters.

Parameters:

Returns:



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

def build_HostClassDefinition(o, name, parameters, parent_class_name, body)
  build_NamedDefinition(o, name, parameters, body)
  o.parent_class = parent_class_name if parent_class_name
  o
end

#build_IfExpression(o, t, ift, els) ⇒ Object 



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

def build_IfExpression(o, t, ift, els)
  o.test = build(t)
  o.then_expr = build(ift)
  o.else_expr= build(els)
  o
end

#build_ImportExpression(o, files) ⇒ Object 



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

def build_ImportExpression(o, files)
  # The argument files has already been built
  files.each {|f| o.addFiles(to_ops(f)) }
  o
end

#build_InstanceReferences(o, type_name, name_expressions) ⇒ Object 



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

def build_InstanceReferences(o, type_name, name_expressions)
  o.type_name = build(type_name)
  name_expressions.each {|n| o.addNames(build(n)) }
  o
end

#build_KeyedEntry(o, k, v) ⇒ Object 



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

def build_KeyedEntry(o, k, v)
  o.key = build(k)
  o.value = build(v)
  o
end

#build_LiteralHash(o, *keyed_entries) ⇒ Object 



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

def build_LiteralHash(o, *keyed_entries)
  keyed_entries.each {|entry| o.addEntries build(entry) }
  o
end

#build_LiteralList(o, *values) ⇒ Object 



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

def build_LiteralList(o, *values)
  values.each {|v| o.addValues build(v) }
  o
end

#build_LiteralNumber(o, val, radix) ⇒ Object 



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

def build_LiteralNumber(o, val, radix)
  o.value = val
  o.radix = radix
  o
end

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



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

def build_MatchExpression(o, op, a, b)
  o.operator = op
  build_BinaryExpression(o, a, b)
end

#build_NamedDefinition(o, name, parameters, body) ⇒ Object 



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

def build_NamedDefinition(o, name, parameters, body)
  build_Definition(o, parameters, body)
  o.name = name
  o
end

#build_NilClass(o) ⇒ Object 



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

def build_NilClass(o)
  x = Model::Nop.new
  x
end

#build_NodeDefinition(o, hosts, parent, body) ⇒ Object

Parameters:



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

def build_NodeDefinition(o, hosts, parent, body)
  hosts.each {|h| o.addHost_matches(build(h)) }
  o.parent = build(parent) if parent # no nop here
  b = f_build_body(body)
  o.body = b.current if b
  o
end

#build_Parameter(o, name, expr) ⇒ Object 



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

def build_Parameter(o, name, expr)
  o.name = name
  o.value = build(expr) if expr # don't build a nil/nop
  o
end

#build_QualifiedName(o, name) ⇒ Object 



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

def build_QualifiedName(o, name)
  o.value = name.to_s
  o
end

#build_QualifiedReference(o, name) ⇒ Object 



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

def build_QualifiedReference(o, name)
  o.value = name.to_s.downcase
  o
end

#build_QueryExpression(o, expr) ⇒ Object 



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

def build_QueryExpression(o, expr)
  ops = to_ops(expr)
  o.expr = ops unless Puppet::Pops::Model::Factory.nop? ops
  o
end

#build_Regexp(o) ⇒ Object 



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

def build_Regexp(o)
  x = Model::LiteralRegularExpression.new
  x.value = o;
  x
end

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



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

def build_RelationshipExpression(o, op, a, b)
  o.operator = op
  build_BinaryExpression(o, a, b)
end

#build_ResourceBody(o, title_expression, attribute_operations) ⇒ Object 



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

def build_ResourceBody(o, title_expression, attribute_operations)
  o.title = build(title_expression)
  attribute_operations.each {|ao| o.addOperations(build(ao)) }
  o
end

#build_ResourceDefaultsExpression(o, type_ref, attribute_operations) ⇒ Object 



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

def build_ResourceDefaultsExpression(o, type_ref, attribute_operations)
  o.type_ref = build(type_ref)
  attribute_operations.each {|ao| o.addOperations(build(ao)) }
  o
end

#build_ResourceExpression(o, type_name, bodies) ⇒ Object 



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

def build_ResourceExpression(o, type_name, bodies)
  o.type_name = build(type_name)
  bodies.each {|b| o.addBodies(build(b)) }
  o
end

#build_ResourceOverrideExpression(o, resources, attribute_operations) ⇒ Object

# @param name [String] a valid classname

# @param parameters [Array<Model::Parameter>] may be empty
# @param body [Array<Expression>, Expression, nil] expression that constitute the body
# @return [Model::HostClassDefinition] configured from the parameters
#
def build_ResourceTypeDefinition(o, name, parameters, body)
  build_NamedDefinition(o, name, parameters, body)
  o.name = name
  parameters.each {|p| o.addParameters(build(p)) }
  b = f_build_body(body)
  o.body = b.current if b
  o
end



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

def build_ResourceOverrideExpression(o, resources, attribute_operations)
  o.resources = build(resources)
  attribute_operations.each {|ao| o.addOperations(build(ao)) }
  o
end

#build_SelectorEntry(o, matching, value) ⇒ Object 



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

def build_SelectorEntry(o, matching, value)
  o.matching_expr = build(matching)
  o.value_expr = build(value)
  o
end

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



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

def build_SelectorExpression(o, left, *selectors)
  o.left_expr = to_ops(left)
  selectors.each {|s| o.addSelectors(build(s)) }
  o
end

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



690
691
692
693
694
 
# File 'lib/puppet/pops/model/factory.rb', line 690

def build_String(o)
  x = Model::LiteralString.new
  x.value = o;
  x
end

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



738
739
740
741
742
743
744
745
746
747
 
# File 'lib/puppet/pops/model/factory.rb', line 738

def build_Symbol(o)
  case o
  when :undef
    Model::LiteralUndef.new
  when :default
    Model::LiteralDefault.new
  else
    build_String(o.to_s)
  end
end

#build_TrueClass(o) ⇒ Object 



701
702
703
704
705
 
# File 'lib/puppet/pops/model/factory.rb', line 701

def build_TrueClass(o)
  x = Model::LiteralBoolean.new
  x.value = o
  x
end

#build_UnaryExpression(o, expr) ⇒ Object 



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

def build_UnaryExpression(o, expr)
  ops = to_ops(expr)
  o.expr = ops unless Puppet::Pops::Model::Factory.nop? ops
  o
end

#default(r) ⇒ Object

For CaseExpression, setting the default for an already build CaseExpression



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

def default r
  current.addOptions(Puppet::Pops::Model::Factory.WHEN(:default, r).current)
  self
end

#doc ⇒ String?

Returns documentation string, or nil if not available

Returns:

  • (String, nil) —

    associated documentation if available



455
456
457
458
459
 
# File 'lib/puppet/pops/model/factory.rb', line 455

def doc()
  a = Puppet::Pops::Adapters::SourcePosAdapter.adapt(current)
  return a.documentation if a
  nil
end

#doc=(doc_string) ⇒ Object 



461
462
463
464
 
# File 'lib/puppet/pops/model/factory.rb', line 461

def doc=(doc_string)
  a = Puppet::Pops::Adapters::SourcePosAdapter.adapt(current)
  a.documentation = doc_string
end

#dot(r) ⇒ Object 



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

def dot r;    f_build_binary(Model::NamedAccessExpression, current, r); end

#f_arithmetic(op, r) ⇒ Object 



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

def f_arithmetic(op, r)
  f_build_binary_op(Model::ArithmeticExpression, op, current, r)
end

#f_build_binary(klazz, left, right) ⇒ Object 



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

def f_build_binary(klazz, left, right)
  Puppet::Pops::Model::Factory.new(build(klazz.new, left, right))
end

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



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

def f_build_binary_op(klazz, op, left, right)
  Puppet::Pops::Model::Factory.new(build(klazz.new, op, left, right))
end

#f_build_body(nothing) ⇒ Object #f_build_body(array) ⇒ Object #f_build_body(expr) ⇒ Object #f_build_body(obj) ⇒ Object

Builds body :) from different kinds of input

Overloads:

  • #f_build_body(nothing) ⇒ Object

    Parameters:

    • nothing (nil) —

      unchanged, produces nil

  • #f_build_body(array) ⇒ Object

    Parameters:

  • #f_build_body(expr) ⇒ Object

    Parameters:

    • expr (Expression) —

      produces the given expression

  • #f_build_body(obj) ⇒ Object

    Parameters:

    • obj (Object) —

      produces the result of calling #build with body as argument



193
194
195
196
197
198
199
200
201
202
 
# File 'lib/puppet/pops/model/factory.rb', line 193

def f_build_body(body)
  case body
  when NilClass
    nil
  when Array
    Puppet::Pops::Model::Factory.new(Model::BlockExpression, *body)
  else
    build(body)
  end
end

#f_build_unary(klazz, expr) ⇒ Object

Puppet::Pops::Model::Factory helpers



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

def f_build_unary(klazz, expr)
  Puppet::Pops::Model::Factory.new(build(klazz.new, expr))
end

#f_build_vararg(klazz, left, *arg) ⇒ Object 



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

def f_build_vararg(klazz, left, *arg)
  Puppet::Pops::Model::Factory.new(build(klazz.new, left, *arg))
end

#f_comparison(op, r) ⇒ Object 



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

def f_comparison(op, r)
  f_build_binary_op(Model::ComparisonExpression, op, current, r)
end

#f_match(op, r) ⇒ Object 



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

def f_match(op, r)
  f_build_binary_op(Model::MatchExpression, op, current, r)
end

#in(r) ⇒ Object

Operator helpers



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

def in(r)     f_build_binary(Model::InExpression, current, r);          end

#lambda=(lambda) ⇒ Object 



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

def lambda=(lambda)
  current.lambda = lambda.current
  self
end

#loc ⇒ Puppet::Pops::Adapters::SourcePosAdapter

Returns with location information.

Returns:



449
450
451
 
# File 'lib/puppet/pops/model/factory.rb', line 449

def loc()
  Puppet::Pops::Adapters::SourcePosAdapter.adapt(current)
end

#minus ⇒ Object 



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

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

#mne(r) ⇒ Object 



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

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

#ne(r) ⇒ Object 



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

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

#not ⇒ Object 



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

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

#or(r) ⇒ Object 



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

def or(r)     f_build_binary(Model::OrExpression, current, r);          end

#paren ⇒ Object 



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

def paren();  f_build_unary(Model::ParenthesizedExpression, current);   end

#plus_set(r) ⇒ Object

Assignment +=



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

def plus_set(r)
  f_build_binary_op(Model::AssignmentExpression, :'+=', current, r)
end

#record_origin(file) ⇒ Factory

Records the origin file of an element Does nothing if file is nil.

Parameters:

  • file (String, nil) —

    the file/path to the origin, may contain URI scheme of file: or some other URI scheme

Returns:



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

def record_origin(file)
  return self unless file
  Puppet::Pops::Adapters::OriginAdapter.adapt(current) do |a|
     a.origin = file
  end
  self
end

#record_position(start_pos, end_pos) ⇒ Object

Records the position (start -> end) and computes the resulting length.



421
422
423
424
425
426
427
428
429
430
431
432
 
# File 'lib/puppet/pops/model/factory.rb', line 421

def record_position(start_pos, end_pos)
  Puppet::Pops::Adapters::SourcePosAdapter.adapt(current) do |a|
    a.line   = start_pos.line
    a.offset = start_pos.offset
    a.pos    = start_pos.pos
    a.length = start_pos.length
    if(end_pos.offset && end_pos.length)
      a.length = end_pos.offset + end_pos.length - start_pos.offset
    end
  end
  self
end

#relop(op, r) ⇒ Object 



372
373
374
 
# File 'lib/puppet/pops/model/factory.rb', line 372

def relop op, r
  f_build_binary_op(Model::RelationshipExpression, op.to_sym, current, r)
end

#respond_to?(meth) ⇒ Boolean

Returns:

  • (Boolean) 


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

def respond_to?(meth)
  current.respond_to?(meth) || super
end

#select(*args) ⇒ Object 



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

def select *args
  Puppet::Pops::Model::Factory.new(build(Model::SelectorExpression, current, *args))
end

#set(r) ⇒ Object

Assignment =



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

def set(r)
  f_build_binary_op(Model::AssignmentExpression, :'=', current, r)
end

#text ⇒ Object 



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

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

#to_ops(o, *args) ⇒ Object

Checks if the object is already a model object, or build it



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

def to_ops(o, *args)
  if o.kind_of?(Model::PopsObject)
    o
  else
    build(o, *args)
  end
end

#var ⇒ Object 



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

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