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
STATEMENT_CALLS = 
{
  'require' => true,
  'realize' => true,
  'include' => true,
  'contain' => true,

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

  'fail'    => true,
  'import'  => true  # discontinued, but transform it to make it call error reporting function
}
@@build_visitor =

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

Puppet::Pops::Visitor.new(self, "build")
@@interpolation_visitor = 
Puppet::Pops::Visitor.new(self, "interpolate")

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



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

def initialize o, *args
  @current = case o
  when Model::PopsObject
    o
  when Puppet::Pops::Model::Factory
    o.current
  else
    build(o, *args)
  end
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



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

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 



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

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

.ATTRIBUTE_OP(name, op, expr) ⇒ Object 



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

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

.block(*args) ⇒ Object 



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

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



686
687
688
689
690
691
692
 
# File 'lib/puppet/pops/model/factory.rb', line 686

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 



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

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

.CALL_NAMED(name, rval_required, argument_list) ⇒ Object 



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

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 



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

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

.COLLECT(type_expr, query_expr, attribute_operations) ⇒ Object 



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

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

.concat(*args) ⇒ Object 



965
966
967
968
969
970
971
972
973
974
975
976
977
 
# File 'lib/puppet/pops/model/factory.rb', line 965

def self.concat(*args)
  new(args.map do |e|
    e = e.current if e.is_a?(self)
    case e
    when Model::LiteralString
      e.value
    when String
      e
    else
      raise ArgumentError, "can only concatenate strings, got #{e.class}"
    end
  end.join(''))
end

.DEFINITION(name, parameters, body) ⇒ Object 



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

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

.ENUM(*args) ⇒ Object 



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

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

.EPP(parameters, body) ⇒ Object 



584
585
586
587
588
589
590
591
592
 
# File 'lib/puppet/pops/model/factory.rb', line 584

def self.EPP(parameters, body)
  see_scope = false
  params = parameters
  if parameters.nil?
    params = []
    see_scope = true
  end
  LAMBDA(params, new(Model::EppExpression, see_scope, body))
end

.EXPORTED_QUERY(query_expr) ⇒ Object 



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

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.



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

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.



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

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 



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

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

.HEREDOC(name, expr) ⇒ Object

TODO_HEREDOC



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

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

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



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

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

.IF(test_e, then_e, else_e) ⇒ Object 



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

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

.KEY_ENTRY(key, val) ⇒ Object 



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

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

.LAMBDA(parameters, body) ⇒ Object 



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

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

.LIST(entries) ⇒ Object 



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

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

.literal(o) ⇒ Object

Factory starting points



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

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

.MAP(match, value) ⇒ Object 



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

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

.minus(o) ⇒ Object 



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

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

.NAMED_ACCESS(type_name, bodies) ⇒ Object 



661
662
663
 
# File 'lib/puppet/pops/model/factory.rb', line 661

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

.NODE(hosts, parent, body) ⇒ Object 



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

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

.nop?(o) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

.NUMBER(name_or_numeric) ⇒ Object 



601
602
603
604
605
606
607
608
609
610
611
612
613
 
# File 'lib/puppet/pops/model/factory.rb', line 601

def self.NUMBER(name_or_numeric)
  if n_radix = Puppet::Pops::Utils.to_n_with_radix(name_or_numeric)
    val, radix = n_radix
    if val.is_a?(Float)
      new(Model::LiteralFloat, val)
    else
      new(Model::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 



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

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

.PROGRAM(body, definitions, locator) ⇒ Object 



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

def self.PROGRAM(body, definitions, locator)
  new(Model::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.



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

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

.QNAME_OR_NUMBER(name) ⇒ Object

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



617
618
619
620
621
622
623
624
625
626
627
628
 
# File 'lib/puppet/pops/model/factory.rb', line 617

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

.QREF(name) ⇒ Object 



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

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

.record_position(o, start_locatable, end_locateable) ⇒ Object 



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

def self.record_position(o, start_locatable, end_locateable)
  new(o).record_position(start_locatable, end_locateable)
end

.RENDER_EXPR(expr) ⇒ Object 



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

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

.RENDER_STRING(o) ⇒ Object

TODO_EPP



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

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

.RESOURCE(type_name, bodies) ⇒ Object 



665
666
667
 
# File 'lib/puppet/pops/model/factory.rb', line 665

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

.RESOURCE_BODY(resource_title, attribute_operations) ⇒ Object 



677
678
679
 
# File 'lib/puppet/pops/model/factory.rb', line 677

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

.RESOURCE_DEFAULTS(type_name, attribute_operations) ⇒ Object 



669
670
671
 
# File 'lib/puppet/pops/model/factory.rb', line 669

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

.RESOURCE_OVERRIDE(resource_ref, attribute_operations) ⇒ Object 



673
674
675
 
# File 'lib/puppet/pops/model/factory.rb', line 673

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



493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
 
# File 'lib/puppet/pops/model/factory.rb', line 493

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 



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

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

.SUBLOCATE(token, expr) ⇒ Object 



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

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

.text(o) ⇒ Object 



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

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

.TEXT(expr) ⇒ Object 



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

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

.transform_calls(expressions) ⇒ Object

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



735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
 
# File 'lib/puppet/pops/model/factory.rb', line 735

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) && STATEMENT_CALLS[name.value]
      the_call = Puppet::Pops::Model::Factory.CALL_NAMED(name, false, expr.is_a?(Array) ? expr : [expr])
      # last positioned is last arg if there are several
      record_position(the_call, name, expr.is_a?(Array) ? expr[-1]  : expr)
      memo[-1] = the_call
      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
    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

.transform_resource_wo_title(left, attribute_ops) ⇒ Object

Transforms a left expression followed by an untitled resource (in the form of attribute_operations)

Parameters:



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

def self.transform_resource_wo_title(left, attribute_ops)
  return nil unless attribute_ops.is_a? Array
#    return nil if attribute_ops.find { |ao| ao.operator == :'+>' }
  keyed_entries = attribute_ops.map do |ao|
    return nil if ao.operator == :'+>'
    KEY_ENTRY(ao.attribute_name, ao.value_expr)
  end
  result = block_or_expression(*transform_calls([left, HASH(keyed_entries)]))
  result
end

.TYPE(name, super_name = nil) ⇒ Object 



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

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

.UNLESS(test_e, then_e, else_e) ⇒ Object 



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

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

.var(o) ⇒ Object 



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

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

.VIRTUAL_QUERY(query_expr) ⇒ Object 



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

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

.WHEN(values_list, block) ⇒ Object 



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

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

Instance Method Details

#%(r) ⇒ Object 



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

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

#*(r) ⇒ Object 



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

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

#+(r) ⇒ Object 



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

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

#-(r) ⇒ Object 



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

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

#/(r) ⇒ Object 



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

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

#<(r) ⇒ Object 



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

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

#<<(r) ⇒ Object 



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

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

#<=(r) ⇒ Object 



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

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

#==(r) ⇒ Object 



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

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

#=~(r) ⇒ Object 



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

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

#>(r) ⇒ Object 



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

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

#>=(r) ⇒ Object 



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

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

#>>(r) ⇒ Object 



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

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

#[](*r) ⇒ Object 



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

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

#and(r) ⇒ Object 



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

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

#attributes(*args) ⇒ Object 



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

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

#build(o, *args) ⇒ Object

Polymorphic build



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

def build(o, *args)
  begin
    @@build_visitor.visit_this(self, o, *args)
  rescue =>e
    # debug here when in trouble...
    raise e
  end
end

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



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

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



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

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.



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

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

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



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

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

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



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

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 



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

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 



85
86
87
88
 
# File 'lib/puppet/pops/model/factory.rb', line 85

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



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

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 



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

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 



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

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 



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

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



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

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

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



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

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 



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

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

#build_ConcatenatedString(o, *args) ⇒ Object 



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

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

#build_CreateAttributeExpression(o, name, datatype_expr) ⇒ Object 



119
120
121
122
123
 
# File 'lib/puppet/pops/model/factory.rb', line 119

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

#build_CreateEnumExpression(o, *args) ⇒ Object 



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

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 



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

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

#build_EppExpression(o, see_scope, body) ⇒ Object 



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

def build_EppExpression(o, see_scope, body)
  o.see_scope = see_scope
  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.



830
831
832
 
# File 'lib/puppet/pops/model/factory.rb', line 830

def build_Factory(o)
  o.current
end

#build_FalseClass(o) ⇒ Object 



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

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

#build_Fixnum(o) ⇒ Object 



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

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

#build_Float(o) ⇒ Object 



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

def build_Float(o)
  x = Model::LiteralFloat.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



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

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_HeredocExpression(o, name, expr) ⇒ Object 



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

def build_HeredocExpression(o, name, expr)
  o.syntax = name
  o.text_expr = build(expr)
  o
end

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

Returns configured from the parameters.

Parameters:

Returns:



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

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 



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

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

#build_KeyedEntry(o, k, v) ⇒ Object 



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

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

#build_LambdaExpression(o, parameters, body) ⇒ Object 



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

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

#build_LiteralFloat(o, val) ⇒ Object 



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

def build_LiteralFloat(o, val)
  o.value = val
  o
end

#build_LiteralHash(o, *keyed_entries) ⇒ Object 



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

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

#build_LiteralInteger(o, val, radix) ⇒ Object 



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

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

#build_LiteralList(o, *values) ⇒ Object 



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

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

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



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

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

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



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

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

#build_NilClass(o) ⇒ Object 



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

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

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

Parameters:



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

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 



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

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

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



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

def build_Program(o, body, definitions, locator)
  o.body = to_ops(body)
  # non containment
  definitions.each { |d| o.addDefinitions(d) }
  o.source_ref = locator.file
  o.source_text = locator.string
  o.line_offsets = locator.line_index
  o.locator = locator
  o
end

#build_QualifiedName(o, name) ⇒ Object 



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

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

#build_QualifiedReference(o, name) ⇒ Object 



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

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

#build_QueryExpression(o, expr) ⇒ Object 



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

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 



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

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

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



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

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

#build_RenderStringExpression(o, string) ⇒ Object 



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

def build_RenderStringExpression(o, string)
  o.value = string;
  o
end

#build_ResourceBody(o, title_expression, attribute_operations) ⇒ Object 



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

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 



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

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 



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

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 



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

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 



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

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

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



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

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.



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

def build_String(o)
  x = Model::LiteralString.new
  x.value = o;
  x
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.



285
286
287
288
289
290
291
292
293
294
295
296
 
# File 'lib/puppet/pops/model/factory.rb', line 285

def build_SubLocatedExpression(o, token, expression)
  o.expr = build(expression)
  o.offset = token.offset
  o.length =  token.length
  locator = token.locator
  o.locator = locator
  o.leading_line_count = locator.leading_line_count
  o.leading_line_offset = locator.leading_line_offset
  # Index is held in sublocator's parent locator - needed to be able to reconstruct
  o.line_offsets = locator.locator.line_index
  o
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.



836
837
838
839
840
841
842
843
844
845
 
# File 'lib/puppet/pops/model/factory.rb', line 836

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 



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

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

#build_UnaryExpression(o, expr) ⇒ Object 



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

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



421
422
423
424
 
# File 'lib/puppet/pops/model/factory.rb', line 421

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

#dot(r) ⇒ Object 



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

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

#f_arithmetic(op, r) ⇒ Object 



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

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

#f_build_binary(klazz, left, right) ⇒ Object 



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

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 



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

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



197
198
199
200
201
202
203
204
205
206
 
# File 'lib/puppet/pops/model/factory.rb', line 197

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



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

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

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



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

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

#f_comparison(op, r) ⇒ Object 



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

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

#f_match(op, r) ⇒ Object 



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

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

#in(r) ⇒ Object

Operator helpers



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

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

#interpolate ⇒ Object

Polymorphic interpolate



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

def interpolate()
  begin
    @@interpolation_visitor.visit_this_0(self, current)
  rescue =>e
    # debug here when in trouble...
    raise e
  end
end

#interpolate_AccessExpression(o) ⇒ 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 $



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

def interpolate_AccessExpression(o)
  if is_interop_rewriteable?(o.left_expr)
    o.left_expr = to_ops(self.class.new(o.left_expr).interpolate)
  end
  o
end

#interpolate_CallMethodExpression(o) ⇒ Object

Rewrite method calls on the form $… to $Puppet::Pops::Model::Factory.$x$x.each



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

def interpolate_CallMethodExpression(o)
  if is_interop_rewriteable?(o.functor_expr)
    o.functor_expr = to_ops(self.class.new(o.functor_expr).interpolate)
  end
  o
end

#interpolate_Factory(o) ⇒ Object 



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

def interpolate_Factory(o)
  interpolate(o.current)
end

#interpolate_LiteralInteger(o) ⇒ Object 



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

def interpolate_LiteralInteger(o)
  # convert number to a variable
  self.class.new(o).var
end

#interpolate_NamedAccessExpression(o) ⇒ Object 



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

def interpolate_NamedAccessExpression(o)
  if is_interop_rewriteable?(o.left_expr)
      o.left_expr = to_ops(self.class.new(o.left_expr).interpolate)
  end
  o
end

#interpolate_Object(o) ⇒ Object 



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

def interpolate_Object(o)
  o
end

#interpolate_QualifiedName(o) ⇒ Object 



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

def interpolate_QualifiedName(o)
  self.class.new(o).var
end

#is_interop_rewriteable?(o) ⇒ Boolean

Returns:

  • (Boolean) 


940
941
942
943
944
945
946
947
948
949
950
951
 
# File 'lib/puppet/pops/model/factory.rb', line 940

def is_interop_rewriteable?(o)
  case o
  when Model::AccessExpression, Model::QualifiedName,
    Model::NamedAccessExpression, Model::CallMethodExpression
    true
  when Model::LiteralInteger
    # Only decimal integers can represent variables, else it is a number
    o.radix == 10
  else
    false
  end
end

#lambda=(lambda) ⇒ Object 



426
427
428
429
 
# File 'lib/puppet/pops/model/factory.rb', line 426

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

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

Returns with location information.

Returns:



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

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

#minus ⇒ Object 



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

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

#minus_set(r) ⇒ Object

Assignment -=



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

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

#mne(r) ⇒ Object 



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

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

#name_is_statement(name) ⇒ Object

Returns true if the given name is a “statement keyword” (require, include, contain, error, notice, info, debug



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

def name_is_statement(name)
  STATEMENT_CALLS[name]
end

#ne(r) ⇒ Object 



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

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

#not ⇒ Object 



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

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

#or(r) ⇒ Object 



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

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

#paren ⇒ Object 



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

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

#plus_set(r) ⇒ Object

Assignment +=



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

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

#record_position(start_locatable, end_locatable) ⇒ Object

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



470
471
472
473
474
475
476
477
478
479
 
# File 'lib/puppet/pops/model/factory.rb', line 470

def record_position(start_locatable, end_locatable)
  from = start_locatable.is_a?(Puppet::Pops::Model::Factory) ? start_locatable.current : start_locatable
  to   = end_locatable.is_a?(Puppet::Pops::Model::Factory) ? end_locatable.current  : end_locatable
  to = from if to.nil? || to.offset.nil?
  o = current
  # record information directly in the Model::Positioned object
  o.offset = from.offset
  o.length ||= to.offset - from.offset + to.length
  self
end

#relop(op, r) ⇒ Object 



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

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

#respond_to?(meth, include_all = false) ⇒ Boolean

Returns:

  • (Boolean) 


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

def respond_to?(meth, include_all=false)
  current.respond_to?(meth, include_all) || super
end

#select(*args) ⇒ Object 



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

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

#set(r) ⇒ Object

Assignment =



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

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

#text ⇒ Object 



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

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



954
955
956
957
958
959
960
961
962
963
 
# File 'lib/puppet/pops/model/factory.rb', line 954

def to_ops(o, *args)
  case o
  when Model::PopsObject
    o
  when Puppet::Pops::Model::Factory
    o.current
  else
    build(o, *args)
  end
end

#var ⇒ Object 



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

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