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.

Defined Under Namespace

Classes: ArgsToNonCallError

Constant Summary collapse

Model = 
Puppet::Pops::Model
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
}
@@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



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

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 



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

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

.ATTRIBUTE_OP(name, op, expr) ⇒ Object 



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

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

.ATTRIBUTES_OP(expr) ⇒ Object 



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

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

.block(*args) ⇒ Object 



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

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



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

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 



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

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

.CALL_NAMED(name, rval_required, argument_list) ⇒ Object 



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

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 



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

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

.COLLECT(type_expr, query_expr, attribute_operations) ⇒ Object 



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

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

.concat(*args) ⇒ Object 



1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
 
# File 'lib/puppet/pops/model/factory.rb', line 1039

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 



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

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

.ENUM(*args) ⇒ Object 



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

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

.EPP(parameters, body) ⇒ Object 



631
632
633
634
635
636
637
638
639
640
 
# File 'lib/puppet/pops/model/factory.rb', line 631

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

.EXPORTED_QUERY(query_expr) ⇒ Object 



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

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.



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

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.



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

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 



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

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

.HEREDOC(name, expr) ⇒ Object 



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

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

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



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

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

.IF(test_e, then_e, else_e) ⇒ Object 



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

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

.KEY_ENTRY(key, val) ⇒ Object 



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

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

.LAMBDA(parameters, body) ⇒ Object 



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

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

.LIST(entries) ⇒ Object 



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

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

.literal(o) ⇒ Object

Factory starting points



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

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

.MAP(match, value) ⇒ Object 



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

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

.minus(o) ⇒ Object 



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

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

.NAMED_ACCESS(type_name, bodies) ⇒ Object 



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

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

.NODE(hosts, parent, body) ⇒ Object 



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

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

.nop?(o) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

.NUMBER(name_or_numeric) ⇒ Object 



653
654
655
656
657
658
659
660
661
662
663
664
665
 
# File 'lib/puppet/pops/model/factory.rb', line 653

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 



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

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

.PROGRAM(body, definitions, locator) ⇒ Object 



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

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.



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

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



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

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 



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

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

.record_position(o, start_locatable, end_locateable) ⇒ Object 



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

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

.RENDER_EXPR(expr) ⇒ Object 



627
628
629
 
# File 'lib/puppet/pops/model/factory.rb', line 627

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

.RENDER_STRING(o) ⇒ Object

TODO_EPP



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

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

.RESERVED(name, future = false) ⇒ Object 



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

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

.RESOURCE(type_name, bodies) ⇒ Object 



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

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

.RESOURCE_BODY(resource_title, attribute_operations) ⇒ Object 



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

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

.RESOURCE_DEFAULTS(type_name, attribute_operations) ⇒ Object 



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

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

.RESOURCE_OVERRIDE(resource_ref, attribute_operations) ⇒ Object 



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

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



521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
 
# File 'lib/puppet/pops/model/factory.rb', line 521

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
    # if Resource[e], then it is not resource specific
    if expr.left_expr.is_a?(Model::QualifiedReference) && expr.left_expr.value == 'resource' && expr.keys.size == 1
      :defaults
    else
      :override
    end
  when 'class'
    :class
  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.



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

def self.set_resource_form(expr, form)
  expr = expr.current if expr.is_a?(Puppet::Pops::Model::Factory)
  # Note: Validation handles illegal combinations
  return false unless expr.is_a?(Puppet::Pops::Model::AbstractResource)
  expr.form = form
  return true
end

.string(*args) ⇒ Object 



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

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

.SUBLOCATE(token, expr) ⇒ Object 



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

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

.TEXT(expr) ⇒ Object 



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

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

.text(o) ⇒ Object 



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

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.



800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
 
# File 'lib/puppet/pops/model/factory.rb', line 800

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]
      if expr.is_a?(Array)
        expr = expr.reject {|e| e.is_a?(Puppet::Pops::Parser::LexerSupport::TokenValue) }
      else
        expr = [expr]
      end
      the_call = Puppet::Pops::Model::Factory.CALL_NAMED(name, false, 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
    elsif expr.is_a?(Array)
      raise ArgsToNonCallError.new(expr, name)
    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:



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

def self.transform_resource_wo_title(left, attribute_ops)
  # Returning nil means accepting the given as a potential resource expression
  return nil unless attribute_ops.is_a? Array
  return nil unless left.current.is_a?(Puppet::Pops::Model::QualifiedName)
  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 



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

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

.unfold(o) ⇒ Object 



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

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

.UNLESS(test_e, then_e, else_e) ⇒ Object 



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

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

.var(o) ⇒ Object 



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

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

.VIRTUAL_QUERY(query_expr) ⇒ Object 



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

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

.WHEN(values_list, block) ⇒ Object 



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

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

Instance Method Details

#%(r) ⇒ Object 



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

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

#*(r) ⇒ Object 



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

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

#+(r) ⇒ Object 



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

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

#-(r) ⇒ Object 



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

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

#/(r) ⇒ Object 



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

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

#<(r) ⇒ Object 



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

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

#<<(r) ⇒ Object 



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

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

#<=(r) ⇒ Object 



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

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

#==(r) ⇒ Object 



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

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

#=~(r) ⇒ Object 



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

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

#>(r) ⇒ Object 



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

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

#>=(r) ⇒ Object 



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

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

#>>(r) ⇒ Object 



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

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

#[](*r) ⇒ Object 



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

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

#and(r) ⇒ Object 



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

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

#attributes(*args) ⇒ Object 



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

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 



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

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.



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

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_AttributesOperation(o, value) ⇒ Object 



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

def build_AttributesOperation(o, value)
  o.expr = build(value)
  o
end

#build_BinaryExpression(o, left, right) ⇒ Object 



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

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 



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

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



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

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 



945
946
947
948
949
 
# File 'lib/puppet/pops/model/factory.rb', line 945

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 



951
952
953
954
955
 
# File 'lib/puppet/pops/model/factory.rb', line 951

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 



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

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



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

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

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



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

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 



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

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

#build_ConcatenatedString(o, *args) ⇒ Object 



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

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

#build_CreateAttributeExpression(o, name, datatype_expr) ⇒ Object 



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

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

#build_CreateEnumExpression(o, *args) ⇒ Object 



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

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 



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

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

#build_EppExpression(o, parameters_specified, body) ⇒ Object 



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

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



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

def build_Factory(o)
  o.current
end

#build_FalseClass(o) ⇒ Object 



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

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

#build_Fixnum(o) ⇒ Object 



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

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

#build_Float(o) ⇒ Object 



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

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



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

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 



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

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:



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

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 



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

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 



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

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

#build_LambdaExpression(o, parameters, body) ⇒ Object 



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

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 



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

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

#build_LiteralHash(o, *keyed_entries) ⇒ Object 



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

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

#build_LiteralInteger(o, val, radix) ⇒ Object 



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

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

#build_LiteralList(o, *values) ⇒ Object 



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

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

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



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

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

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



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

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 



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

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

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

Parameters:



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

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 



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

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 



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

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 



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

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

#build_QualifiedReference(o, name) ⇒ Object 



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

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

#build_QueryExpression(o, expr) ⇒ Object 



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

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 



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

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

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



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

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

#build_RenderStringExpression(o, string) ⇒ Object 



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

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

#build_ReservedWord(o, name, future) ⇒ Object 



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

def build_ReservedWord(o, name, future)
  o.word = name
  o.future = future
  o
end

#build_ResourceBody(o, title_expression, attribute_operations) ⇒ Object 



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

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 



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

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 



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

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 



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

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 



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

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

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



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

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.



854
855
856
857
858
 
# File 'lib/puppet/pops/model/factory.rb', line 854

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.



296
297
298
299
300
301
302
303
304
305
306
307
 
# File 'lib/puppet/pops/model/factory.rb', line 296

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. Supports :undef because nil creates a no-op instruction.



910
911
912
913
914
915
916
917
918
919
 
# File 'lib/puppet/pops/model/factory.rb', line 910

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_TokenValue(o) ⇒ Object 



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

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_TrueClass(o) ⇒ Object 



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

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

#build_UnaryExpression(o, expr) ⇒ Object 



321
322
323
324
325
 
# File 'lib/puppet/pops/model/factory.rb', line 321

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

#captures_rest ⇒ Object

Mark parameter as capturing the rest of arguments



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

def captures_rest()
  current.captures_rest = true
end

#default(r) ⇒ Object

For CaseExpression, setting the default for an already build CaseExpression



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

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

#dot(r) ⇒ Object 



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

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

#f_arithmetic(op, r) ⇒ Object 



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

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

#f_build_binary(klazz, left, right) ⇒ Object 



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

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 



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

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



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

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



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

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

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



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

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

#f_comparison(op, r) ⇒ Object 



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

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

#f_match(op, r) ⇒ Object 



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

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

#in(r) ⇒ Object

Operator helpers



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

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 $



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

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



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

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 



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

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

#interpolate_LiteralInteger(o) ⇒ Object 



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

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

#interpolate_NamedAccessExpression(o) ⇒ Object 



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

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 



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

def interpolate_Object(o)
  o
end

#interpolate_QualifiedName(o) ⇒ Object 



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

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

#is_interop_rewriteable?(o) ⇒ Boolean

Returns:

  • (Boolean) 


1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
 
# File 'lib/puppet/pops/model/factory.rb', line 1014

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 



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

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

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

Returns with location information.

Returns:



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

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

#minus ⇒ Object 



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

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

#minus_set(r) ⇒ Object

Assignment -=



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

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

#mne(r) ⇒ Object 



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

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



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

def name_is_statement(name)
  STATEMENT_CALLS[name]
end

#ne(r) ⇒ Object 



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

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

#not ⇒ Object 



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

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

#or(r) ⇒ Object 



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

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

#paren ⇒ Object 



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

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

#plus_set(r) ⇒ Object

Assignment +=



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

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.



487
488
489
490
491
492
493
494
495
496
 
# File 'lib/puppet/pops/model/factory.rb', line 487

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 



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

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) 


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

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

#select(*args) ⇒ Object 



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

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

#set(r) ⇒ Object

Assignment =



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

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

#text ⇒ Object 



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

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



1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
 
# File 'lib/puppet/pops/model/factory.rb', line 1028

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

#to_s ⇒ Object 



1053
1054
1055
 
# File 'lib/puppet/pops/model/factory.rb', line 1053

def to_s
  Puppet::Pops::Model::ModelTreeDumper.new.dump(self)
end

#type_expr(o) ⇒ Object

Set Expression that should evaluate to the parameter’s type



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

def type_expr(o)
  current.type_expr = to_ops(o)
end

#unfold ⇒ Object 



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

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

#var ⇒ Object 



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

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