module TaskJuggler::TjpSyntaxRules

# File lib/taskjuggler/TjpSyntaxRules.rb, line 21
def rule_absoluteTaskId
  pattern(%w( !taskIdUnverifd ), lambda {
    id = (@taskprefix.empty? ? '' : @taskprefix + '.') + @val[0]
    if (task = @project.task(id)).nil?
      error('unknown_abs_task', "Unknown task #{id}", @sourceFileInfo[0])
    end
    task
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 31
  def rule_account
    pattern(%w( !accountHeader !accountBody ), lambda {
       @property = @property.parent
    })
    doc('account', <<'EOT'
Declares an account. Accounts can be used to calculate costs of tasks or the
whole project. Account declaration may be nested, but only leaf accounts may
be used to track turnover. When the cost of a task is split over multiple
accounts they all must have the same top-level group account. Top-level
accounts can be used for profit/loss calculations. The sub-account structure
of a top-level account should be organized accordingly.

Accounts have a global name space. All IDs must be unique within the accounts of the project.
EOT
       )
    example('Account', '1')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 49
def rule_accountAttributes
  repeatable
  optional
  pattern(%w( !account))
  pattern(%w( !accountScenarioAttributes ))
  pattern(%w( !scenarioIdCol !accountScenarioAttributes ), lambda {
    @scenarioIdx = 0
  })
  # Other attributes will be added automatically.
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 60
def rule_accountBody
  optionsRule('accountAttributes')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 64
def rule_accountCredit
  pattern(%w( !valDate $STRING !number ), lambda {
    AccountCredit.new(@val[0], @val[1], @val[2])
  })
  arg(1, 'description', 'Short description of the transaction')
  arg(2, 'amount', 'Amount to be booked.')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 72
def rule_accountCredits
  listRule('moreAccountCredits', '!accountCredit')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 76
def rule_accountHeader
  pattern(%w( _account !optionalID $STRING ), lambda {
    if @property.nil? && !@accountprefix.empty?
      @property = @project.account(@accountprefix)
    end
    if @val[1] && @project.account(@val[1])
      error('account_exists', "Account #{@val[1]} has already been defined.",
            @sourceFileInfo[1], @property)
    end
    @property = Account.new(@project, @val[1], @val[2], @property)
    @property.sourceFileInfo = @sourceFileInfo[0]
    @property.inheritAttributes
    @scenarioIdx = 0
  })
  arg(2, 'name', 'A name or short description of the account')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 93
def rule_accountId
  pattern(%w( $ID ), lambda {
    id = @val[0]
    id = @accountprefix + '.' + id unless @accountprefix.empty?
    # In case we have a nested supplement, we need to prepend the parent ID.
    id = @property.fullId + '.' + id if @property && @property.is_a?(Account)
    if (account = @project.account(id)).nil?
      error('unknown_account', "Unknown account #{id}", @sourceFileInfo[0])
    end
    account
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 106
  def rule_accountReport
    pattern(%w( !accountReportHeader !reportBody ), lambda {
      @property = @property.parent
    })
    level(:beta)
    doc('accountreport', <<'EOT'
The report lists accounts and their respective values in a table. The report
can operate in two modes:

# Balance mode: If a [[balance]] has been set, the report will include the
defined cost and revenue accounts as well as all their sub accounts. To reduce
the list of included accounts, you can use the [[hideaccount]],
[[rollupaccount]] or [[accountroot]] attributes. The order of the task can
be controlled with [[sortaccounts]]. If the first sorting criteria is tree
sorting, the parent accounts will always be included to form the tree.
Tree sorting is the default. You need to change it if you do not want certain
parent accounts to be included in the report. Additionally, it will contain a line at the end that lists the balance (revenue - cost).

# Normal mode: All reports are listed in the order and completeness as defined
by the other report attributes. No balance line will be included.
EOT
       )
    example('AccountReport')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 131
def rule_accountReportHeader
  pattern(%w( _accountreport !optionalID !reportName ), lambda {
    newReport(@val[1], @val[2], :accountreport, @sourceFileInfo[0]) do
      unless @property.modified?('columns')
        # Set the default columns for this report.
        %w( bsi name monthly ).each do |col|
          @property.get('columns') <<
          TableColumnDefinition.new(col, columnTitle(col))
        end
      end
      # Show all accounts, sorted by tree, seqno-up.
      unless @property.modified?('hideAccount')
        @property.set('hideAccount',
                      LogicalExpression.new(LogicalOperation.new(0)))
      end
      unless @property.modified?('sortAccounts')
        @property.set('sortAccounts',
                      [ [ 'tree', true, -1 ],
                        [ 'seqno', true, -1 ] ])
      end
    end
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 155
  def rule_accountScenarioAttributes
    pattern(%w( _aggregate !aggregate ), lambda {
      @property.set('aggregate', @val[1])
    })
    doc('aggregate', <<'EOT'
Specifies whether the account is used to track task or resource specific
amounts. The default is to track tasks.
EOT
       )
    example('AccountReport')

    pattern(%w( _credits !accountCredits ), lambda {
      @property['credits', @scenarioIdx] += @val[1]
    })
    doc('credits', <<'EOT'
Book the specified amounts to the account at the specified date. The
desciptions are just used for documentary purposes.
EOT
       )
    example('Account', '1')

    pattern(%w( !flags ))
    doc('flags.account', <<'EOT'
Attach a set of flags. The flags can be used in logical expressions to filter
properties from the reports.
EOT
       )

    # Other attributes will be added automatically.
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 186
def rule_aggregate
  pattern(%w( _resources ), lambda {
    :resources
  })
  descr('Aggregate resources')

  pattern(%w( _tasks ), lambda {
    :tasks
  })
  descr('Aggregate tasks')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 198
  def rule_alertLevel
    pattern(%w( $ID ), lambda {
      level = @project['alertLevels'].indexById(@val[0])
      unless level
        levels = @project['alertLevels'].map { |l| l.id }
        error('bad_alert', "Unknown alert level #{@val[0]}. Must be " +
              "one of #{levels.join(', ')}", @sourceFileInfo[0])
      end
      level
    })
    arg(0, 'alert level', <<'EOT'
By default supported values are ''''green'''', ''''yellow'''' and ''''red''''.
The default value is ''''green''''. You can define your own levels with
[[alertlevels]].
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 216
def rule_alertLevelDefinition
  pattern(%w( $ID $STRING !color ), lambda {
    [ @val[0], @val[1], @val[2] ]
  })
  arg(0, 'ID', "A unique ID for the alert level")
  arg(1, 'color name', 'A unique name of the alert level color')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 224
def rule_alertLevelDefinitions
  listRule('moreAlertLevelDefinitions', '!alertLevelDefinition')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 415
def rule_allOrNone
  pattern(%w( _all ), lambda {
    1
  })
  pattern(%w( _none ), lambda {
    0
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 228
  def rule_allocate
    pattern(%w( _allocate !allocations ), lambda {
      checkContainer('allocate')
      @property['allocate', @scenarioIdx] += @val[1]
    })
    doc('allocate', <<'EOT'
Specify which resources should be allocated to the task. The
attributes provide numerous ways to control which resource is used and when
exactly it will be assigned to the task. Shifts and limits can be used to
restrict the allocation to certain time intervals or to limit them to a
certain maximum per time period. The purge statement can be used to remove
inherited allocations or flags.

For effort-based tasks the task duration is clipped to only extend from the
beginning of the first allocation to the end of the last allocation. This is
done to optimize for an overall minimum project duration as dependent tasks
can potentially use the unallocated, clipped slots.
EOT
       )
    example('Allocate-1', '1')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 403
def rule_allocateShiftAssignments
  pattern(%w( _shift ), lambda {
    @shiftAssignments = @allocate.shifts
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 409
def rule_allocateShiftsAssignments
  pattern(%w( _shifts ), lambda {
    @shiftAssignments = @allocate.shifts
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 250
def rule_allocation
  pattern(%w( !allocationHeader !allocationBody ), lambda {
    @val[0]
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 256
  def rule_allocationAttributes
    optional
    repeatable

    pattern(%w( _alternative !resourceId !moreAlternatives ), lambda {
      ([ @val[1] ] + (@val[2] ? @val[2] : [])).each do |candidate|
        @allocate.addCandidate(candidate)
      end
    })
    doc('alternative', <<'EOT'
Specify which resources should be allocated to the task. The optional
attributes provide numerous ways to control which resource is used and when
exactly it will be assigned to the task. Shifts and limits can be used to
restrict the allocation to certain time intervals or to limit them to a
certain maximum per time period.
EOT
       )
    example('Alternative', '1')

    pattern(%w( !limits ), lambda {
      limits = @property['limits', @scenarioIdx] = @val[0]
      @allocate.candidates.each do |resource|
         limits.limits.each do |l|
           l.resource = resource if resource.leaf?
         end
      end
    })
    level(:removed)
    doc('limits.allocate', '')

    pattern(%w( _select !allocationSelectionMode ), lambda {
      @allocate.setSelectionMode(@val[1])
    })
    doc('select', <<'EOT'
The select function controls which resource is picked from an allocation and
it's alternatives. The selection is re-evaluated each time the resource used
in the previous time slot becomes unavailable.

Even for non-persistent allocations a change in the resource selection only
happens if the resource used in the previous (or next for ASAP tasks) time
slot has become unavailable.
EOT
       )

    pattern(%w( _persistent ), lambda {
      @allocate.persistent = true
    })
    doc('persistent', <<'EOT'
Specifies that once a resource is picked from the list of alternatives, this
resource is used for the whole task. This is useful when several alternative
resources have been specified. Normally the selected resource can change after
each break. A break is an interval of at least one timeslot where no resources
were available.
EOT
       )

    pattern(%w( _mandatory ), lambda {
      @allocate.mandatory = true
    })
    doc('mandatory', <<'EOT'
Makes a resource allocation mandatory. This means, that for each time slot
only then resources are allocated when all mandatory resources are available.
So either all mandatory resources can be allocated for the time slot, or no
resource will be allocated.
EOT
       )
    pattern(%w( !allocateShiftAssignments !shiftAssignment ), lambda {
      begin
        @allocate.shifts = @shiftAssignments
      rescue AttributeOverwrite
        # Multiple shift assignments are a common idiom, so don't warn about
        # them.
      end
      @shiftAssignments = nil
    })
    level(:deprecated)
    also('shifts.allocate')
    doc('shift.allocate', <<'EOT'
Limits the allocations of resources during the specified interval to the
specified shift. Multiple shifts can be defined, but shift intervals may not
overlap. Allocation shifts are an additional restriction to the
[[shifts.task|task shifts]] and [[shifts.resource|resource shifts]] or
[[workinghours.resource|resource working hours]]. Allocations will only be
made for time slots that are specified as duty time in all relevant shifts.
The restriction to the shift is only active during the specified time
interval. Outside of this interval, no restrictions apply.
EOT
       )

    pattern(%w( !allocateShiftsAssignments !shiftAssignments ), lambda {
      begin
        @allocate.shifts = @shiftAssignments
      rescue AttributeOverwrite
        # Multiple shift assignments are a common idiom, so don't warn about
        # them.
      end
      @shiftAssignments = nil
    })
    doc('shifts.allocate', <<'EOT'
Limits the allocations of resources during the specified interval to the
specified shift. Multiple shifts can be defined, but shift intervals may not
overlap. Allocation shifts are an additional restriction to the
[[shifts.task|task shifts]] and [[shifts.resource|resource shifts]] or
[[workinghours.resource|resource working hours]]. Allocations will only be
made for time slots that are specified as duty time in all relevant shifts.
The restriction to the shift is only active during the specified time
interval. Outside of this interval, no restrictions apply.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 367
def rule_allocationBody
  optionsRule('allocationAttributes')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 371
def rule_allocationHeader
  pattern(%w( !resourceId ), lambda {
    @allocate = Allocation.new([ @val[0] ])
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 381
  def rule_allocationSelectionMode
    singlePattern('_maxloaded')
    descr('Pick the available resource that has been used the most so far.')

    singlePattern('_minloaded')
    descr('Pick the available resource that has been used the least so far.')

    singlePattern('_minallocated')
    descr(<<'EOT'
Pick the resource that has the smallest allocation factor. The
allocation factor is calculated from the various allocations of the resource
across the tasks. This is the default setting.
EOT
         )

    singlePattern('_order')
    descr('Pick the first available resource from the list.')

    singlePattern('_random')
    descr('Pick a random resource from the list.')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 377
def rule_allocations
  listRule('moreAllocations', '!allocation')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 424
def rule_argument
  singlePattern('$ABSOLUTE_ID')
  singlePattern('!date')
  singlePattern('$ID')
  singlePattern('$INTEGER')
  singlePattern('$FLOAT')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 432
def rule_argumentList
  optional
  pattern(%w( _( !argumentListBody _) ), lambda {
    @val[1].nil? ? [] : @val[1]
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 439
def rule_argumentListBody
  optional
  pattern(%w( !argument !moreArguments ), lambda {
    [ @val[0] ] + (@val[1].nil? ? [] : @val[1])
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 446
  def rule_author
    pattern(%w( _author !resourceId ), lambda {
      @journalEntry.author = @val[1]
    })
    doc('author', <<'EOT'
This attribute can be used to capture the authorship or source of the
information.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 457
  def rule_balance
    pattern(%w( _balance !balanceAccounts ), lambda {
      @val[1]
    })
    doc('balance', <<'EOT'
During report generation, TaskJuggler can consider some accounts to be revenue accounts, while other can be considered cost accounts. By using the balance attribute, two top-level accounts can be designated for a profit-loss-analysis. This analysis includes all sub accounts of these two top-level accounts.

To clear a previously set balance, just use a ''''-''''.
EOT
       )
    example('AccountReport')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 470
  def rule_balanceAccounts
    pattern(%w( !accountId !accountId ), lambda {
      if @val[0].parent
        error('cost_acct_no_top',
              "The cost account #{@val[0].fullId} is not a top-level account.",
              @sourceFileInfo[0])
      end
      if @val[1].parent
        error('rev_acct_no_top',
              "The revenue account #{@val[1].fullId} is not a top-level " +
              "account.", @sourceFileInfo[1])
      end
      if @val[0] == @val[1]
        error('cost_rev_same',
              'The cost and revenue accounts may not be the same.',
              @sourceFileInfo[0])
      end
      [ @val[0], @val[1] ]
    })
    arg(0, 'cost account', <<'EOT'
The top-level account that is used for all cost related charges.
EOT
       )
    arg(2, 'revenue account', <<'EOT'
The top-level account that is used for all revenue related charges.
EOT
       )

    pattern([ '_-' ], lambda {
      [ nil, nil ]
    })
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 503
  def rule_bookingAttributes
    optional
    repeatable

    pattern(%w( _overtime $INTEGER ), lambda {
      if @val[1] < 0 || @val[1] > 2
        error('overtime_range',
              "Overtime value #{@val[1]} out of range (0 - 2).",
              @sourceFileInfo[1], @property)
      end
      @booking.overtime = @val[1]
    })
    doc('overtime.booking', <<'EOT'
This attribute enables bookings during off-hours and leaves. It implicitly
sets the [[sloppy.booking|sloppy]] attribute accordingly.
EOT
       )
    arg(1, 'value', <<'EOT'
* '''0''': You can only book available working time. (Default)

* '''1''': You can book off-hours as well.

* '''2''': You can book working time, off-hours and vacation time.
EOT
       )

    pattern(%w( _sloppy $INTEGER ), lambda {
      if @val[1] < 0 || @val[1] > 2
        error('sloppy_range',
              "Sloppyness value #{@val[1]} out of range (0 - 2).",
              @sourceFileInfo[1], @property)
      end
      @booking.sloppy = @val[1]
    })
    doc('sloppy.booking', <<'EOT'
Controls how strict TaskJuggler checks booking intervals for conflicts with
working periods and leaves. This attribute only affects the check for
conflicts. No assignments will be made unless the [[overtime.booking|
overtime]] attribute is set accordingly.
EOT
       )
    arg(1, 'sloppyness', <<'EOT'
* '''0''': Period may not contain any off-duty hours, vacation or other task
assignments. (default)

* '''1''': Period may contain off-duty hours, but no vacation time or other
task assignments.

* '''2''': Period may contain off-duty hours and vacation time, but no other
task assignments.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 557
def rule_bookingBody
  optionsRule('bookingAttributes')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 561
def rule_calendarDuration
  pattern(%w( !number !durationUnit ), lambda {
    convFactors = [ 60.0, # minutes
                    60.0 * 60, # hours
                    60.0 * 60 * 24, # days
                    60.0 * 60 * 24 * 7, # weeks
                    60.0 * 60 * 24 * 30.4167, # months
                    60.0 * 60 * 24 * 365 # years
                   ]
    ((@val[0] * convFactors[@val[1]]) / @project['scheduleGranularity']).to_i
  })
  arg(0, 'value', 'A floating point or integer number')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 614
def rule_chargeMode
  singlePattern('_onstart')
  descr('Charge the amount on starting the task.')

  singlePattern('_onend')
  descr('Charge the amount on finishing the task.')

  singlePattern('_perhour')
  descr('Charge the amount for every hour the task lasts.')

  singlePattern('_perday')
  descr('Charge the amount for every day the task lasts.')

  singlePattern('_perweek')
  descr('Charge the amount for every week the task lasts.')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 631
def rule_chargeSetItem
  pattern(%w( !accountId !optionalPercent ), lambda {
    if @property.is_a?(Task)
      aggregate = :tasks
    elsif @property.is_a?(Resource)
      aggregate = :resources
    else
      raise "Unknown property type #{@property.class}"
    end

    if @val[0].get('aggregate') != aggregate
      error('account_bad_aggregate',
            "The account #{@val[0].fullId} cannot aggregate amounts " +
            "related to #{aggregate}.")
    end

    [ @val[0], @val[1] ]
  })
  arg(0, 'account', 'The ID of a previously defined leaf account.')
  arg(1, 'share', 'A percentage between 0 and 100%')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 575
  def rule_chargeset
    pattern(%w( _chargeset !chargeSetItem !moreChargeSetItems ), lambda {
      checkContainer('chargeset')
      items = [ @val[1] ]
      items += @val[2] if @val[2]
      chargeSet = ChargeSet.new
      begin
        items.each do |item|
          chargeSet.addAccount(item[0], item[1])
        end
        chargeSet.complete
      rescue TjException
        error('chargeset', $!.message, @sourceFileInfo[0], @property)
      end
      masterAccounts = []
      @property['chargeset', @scenarioIdx].each do |set|
        masterAccounts << set.master
      end
      if masterAccounts.include?(chargeSet.master)
        error('chargeset_master',
              "All charge sets for this property must have different " +
              "top-level accounts.", @sourceFileInfo[0], @property)
      end
      @property['chargeset', @scenarioIdx] =
        @property['chargeset', @scenarioIdx] + [ chargeSet ]
    })
    doc('chargeset', <<'EOT'
A chargeset defines how the turnover associated with the property will be
charged to one or more accounts. A property may have any number of charge sets,
but each chargeset must deal with a different top-level account. A charge set
consists of one or more accounts. Each account must be a leaf account. The
account ID may be followed by a percentage value that determines the share for
this account. The total percentage of all accounts must be exactly 100%. If
some accounts don't have a percentage specification, the remainder to 100% is
distributed evenly between them.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 653
def rule_chartScale
  singlePattern('_hour')
  descr('Set chart resolution to 1 hour.')

  singlePattern('_day')
  descr('Set chart resolution to 1 day.')

  singlePattern('_week')
  descr('Set chart resolution to 1 week.')

  singlePattern('_month')
  descr('Set chart resolution to 1 month.')

  singlePattern('_quarter')
  descr('Set chart resolution to 1 quarter.')

  singlePattern('_year')
  descr('Set chart resolution to 1 year.')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 673
  def rule_color
    pattern(%w( $STRING ), lambda {
      col = @val[0]
      unless /#[0-9A-Fa-f]{3}/ =~ col || /#[0-9A-Fa-f]{6}/ =~ col
        error('bad_color',
              "Color values must be specified as '#RGB' or '#RRGGBB' values",
              @sourceFileInfo[0])
      end
      col
    })
    arg(0, 'color', <<'EOT'
The RGB color values of the color. The following formats are supported: #RGB
and #RRGGBB. Where R, G, B are hexadecimal values. See
[http://en.wikipedia.org/wiki/Web_colors Wikipedia] for more details.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 691
def rule_columnBody
  optionsRule('columnOptions')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 695
def rule_columnDef
  pattern(%w( !columnId !columnBody ), lambda {
    @val[0]
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 701
  def rule_columnId
    pattern(%w( !reportableAttributes ), lambda {
      @column = TableColumnDefinition.new(@val[0], columnTitle(@val[0]))
    })
    doc('columnid', <<'EOT'
This is a comprehensive list of all pre-defined [[columns]]. In addition to
the listed IDs all user defined attributes can be used as column IDs.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 712
  def rule_columnOptions
    optional
    repeatable

    pattern(%w( _celltext !logicalExpression $STRING ), lambda {
      @column.cellText.addPattern(
        CellSettingPattern.new(newRichText(@val[2], @sourceFileInfo[2]),
                               @val[1]))
    })
    doc('celltext.column', <<'EOT'
Specifies an alternative content that is used for the cells of the column.
Usually such a text contains a query function. Otherwise all cells of the
column will have the same fixed value. The logical expression specifies for
which cells the text should be used. If multiple celltext patterns are
provided for a column, the first matching one is taken for each cell.
EOT
        )
    arg(2, 'text',
        'Alterntive cell text specified as [[Rich_Text_Attributes|Rich Text]]')

    pattern(%w( _cellcolor !logicalExpression !color ), lambda {
      @column.cellColor.addPattern(
        CellSettingPattern.new(@val[2], @val[1]))
    })
    doc('cellcolor.column', <<'EOT'
Specifies an alternative background color for the cells of this column. The
[[logicalexpression|logical expression]] specifies for which cells the color
should be used. If multiple cellcolor patterns are provided for a column, the
first matching one is used for each cell.
EOT
       )

    pattern(%w( _end !date ), lambda {
      @column.end = @val[1]
    })
    doc('end.column', <<'EOT'
Normally, columns with calculated values take the specified report period into
account when calculating their values. With this attribute, the user can
specify an end date for the period that should be used when calculating the
values of this column. It does not have an impact on columns with time
invariant values.
EOT
       )

    pattern(%w( _fontcolor !logicalExpression !color ), lambda {
      @column.fontColor.addPattern(
        CellSettingPattern.new(@val[2], @val[1]))
    })
    doc('fontcolor.column', <<'EOT'
Specifies an alternative font color for the cells of this column. The
[[logicalexpression|logical expression]] specifies for which cells the color
should be used. If multiple fontcolor patterns are provided for a column, the
first matching one is used for each cell.
EOT
       )

    pattern(%w( _halign !logicalExpression !hAlignment ), lambda {
      @column.hAlign.addPattern(
        CellSettingPattern.new(@val[2], @val[1]))
    })
    doc('halign.column', <<'EOT'
Specifies the horizontal alignment of the cell content. The
[[logicalexpression|logical expression]] specifies for which cells the alignment
setting should be used. If multiple halign patterns are provided for a column,
the first matching one is used for each cell.
EOT
       )

    pattern(%w( _listitem $STRING ), lambda {
      @column.listItem = @val[1]
    })
    doc('listitem.column', <<'EOT'
Specifies a [[Rich_Text_Attributes|Rich Text]] pattern that is used to generate the text for the list
items. The pattern should contain at least one ''''<nowiki><</nowiki>-query
attribute='XXX'->'''' element that will be replaced with the value of
attribute XXX. For the replacement, the property of the query will be the list
item.
EOT
       )

    pattern(%w( _listtype !listType ), lambda {
      @column.listType = @val[1]
    })
    also(%w( listitem.column ))
    doc('listtype.column', <<'EOT'
Specifies what type of list should be used. This attribute only affects
columns that contain a list of items.
EOT
       )

    pattern(%w( _period !interval ), lambda {
      @column.start = @val[1].start
      @column.end = @val[1].end
    })
    doc('period.column', <<'EOT'
This property is a shortcut for setting the [[start.column|start]] and
[[end.column|end]] property at the same time.
EOT
       )

    pattern(%w( _scale !chartScale ), lambda {
      @column.scale = @val[1]
    })
    doc('scale.column', <<'EOT'
Specifies the scale that should be used for a chart column. This value is ignored for all other columns.
EOT
       )

    pattern(%w( _start !date ), lambda {
      @column.start = @val[1]
    })
    doc('start.column', <<'EOT'
Normally, columns with calculated values take the specified report period into
account when calculating their values. With this attribute, the user can
specify a start date for the period that should be used when calculating the
values of this column. It does not have an impact on columns with time
invariant values.
EOT
       )

    pattern(%w( _timeformat1 $STRING ), lambda {
      @column.timeformat1 = @val[1]
    })
    doc('timeformat1', <<'EOT'
Specify an alternative format for the upper header line of calendar or Gantt
chart columns.
EOT
       )
    arg(1, 'format', 'See [[timeformat]] for details.')

    pattern(%w( _timeformat2 $STRING ), lambda {
      @column.timeformat2 = @val[1]
    })
    doc('timeformat2', <<'EOT'
Specify an alternative format for the lower header line of calendar or Gantt
chart columns.
EOT
       )
    arg(1, 'format', 'See [[timeformat]] for details.')

    pattern(%w( _title $STRING ), lambda {
      @column.title = @val[1]
    })
    doc('title.column', <<'EOT'
Specifies an alternative title for a report column.
EOT
       )
    arg(1, 'text', 'The new column title.')

    pattern(%w( _tooltip !logicalExpression $STRING ), lambda {
      @column.tooltip.addPattern(
        CellSettingPattern.new(newRichText(@val[2], @sourceFileInfo[2]),
                               @val[1]))
    })
    doc('tooltip.column', <<'EOT'
Specifies an alternative content for the tooltip. This will replace the
original content of the tooltip that would be available for columns with text
that does not fit the column with.  The [[logicalexpression|logical expression]]
specifies for which cells the text should be used. If multiple tooltip
patterns are provided for a column, the first matching one is taken for each
cell.
EOT
       )
    arg(2, 'text', <<'EOT'
The content of the tooltip. The text is interpreted as [[Rich_Text_Attributes|
Rich Text]].
EOT
       )

    pattern(%w( _width !number ), lambda {
      @column.width = @val[1]
    })
    doc('width.column', <<'EOT'
Specifies the maximum width of the column in screen pixels. If the content of
the column does not fit into this width, it will be cut off. In some cases a
scrollbar is added or a tooltip window with the complete content is shown when
the mouse is moved over the column. The latter is only supported in
interactive output formats. The resulting column width may be smaller if the
column has a fixed width (e. g. the chart column).
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 895
def rule_currencyFormat
  pattern(%w( _currencyformat $STRING $STRING $STRING $STRING $INTEGER ),
      lambda {
    RealFormat.new(@val.slice(1, 5))
  })
  doc('currencyformat',
      'These values specify the default format used for all currency ' +
      'values.')
  example('Currencyformat')
  arg(1, 'negativeprefix', 'Prefix for negative numbers')
  arg(2, 'negativesuffix', 'Suffix for negative numbers')
  arg(3, 'thousandsep', 'Separator used for every 3rd digit')
  arg(4, 'fractionsep', 'Separator used to separate the fraction digits')
  arg(5, 'fractiondigits', 'Number of fraction digits to show')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 911
  def rule_date
    pattern(%w( !dateCalcedOrNot ), lambda {
      resolution = @project.nil? ? Project.maxScheduleGranularity :
                                   @project['scheduleGranularity']
      if @val[0] % resolution != 0
        error('misaligned_date',
              "The date must be aligned to the timing resolution (" +
              "#{resolution / 60} min) of the project.",
              @sourceFileInfo[0])
      end
      @val[0]
    })
    doc('date', <<'EOT'
A DATE is date and time specification similar to the ISO 8601 date format.
Instead of the hard to read ISO notation with a ''''T'''' between the date and
time sections, we simply use the more intuitive and easier to read dash:
''''<nowiki>YYYY-MM-DD[-hh:mm[:ss]][-TIMEZONE]</nowiki>''''. Hour, minutes,
seconds, and the ''''TIMEZONE'''' are optional. If not specified, the values
are set to 0.  ''''TIMEZONE'''' must be an offset to GMT or UTC, specified as
''''+HHMM'''' or ''''-HHMM''''. Dates must always be aligned with the
[[timingresolution]].

TaskJuggler also supports simple date calculations. You can add or subtract a
given interval from a fixed date.

 %{2009-11-01 + 8m}

This will result in an actual date of around 2010-07-01. Keep in mind that due
to the varying lengths of months TaskJuggler cannot add exactly 8 calendar
months. The date calculation functionality makes most sense when used with
macros.

 %{${now} - 2w}

This results in a date 2 weeks earlier than the current (or specified) date.
See [[duration]] for a complete list of supported time intervals. Don't forget
to put at least one space character after the date to prevent TaskJuggler from
interpreting the interval as an hour.

Date attributes may be invalid in some cases. This needs special care in
[[logicalexpression|logical expressions]].
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 956
def rule_dateCalcedOrNot
  singlePattern('$DATE')
  pattern(%w( _% _{ $DATE !plusOrMinus !intervalDuration _} ), lambda {
    @val[2] + ((@val[3] == '+' ? 1 : -1) * @val[4])
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 963
def rule_declareFlagList
  listRule('moreDeclareFlagList', '$ID')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 967
  def rule_details
    pattern(%w( _details $STRING ), lambda {
      return if @val[1].empty?

      rtTokenSetMore =
        [ :LINEBREAK, :SPACE, :WORD, :BOLD, :ITALIC, :CODE, :BOLDITALIC,
          :PRE, :HREF, :HREFEND, :REF, :REFEND, :HLINE, :TITLE2, :TITLE3,
          :TITLE4, :TITLE2END, :TITLE3END, :TITLE4END,
          :BULLET1, :BULLET2, :BULLET3, :BULLET4, :NUMBER1, :NUMBER2, :NUMBER3,
          :NUMBER4 ]
      if @val[1] == "Some more details\n"
        error('ts_default_details',
              "'Some more details' is not a valid value",
              @sourceFileInfo[1])
      end
      @journalEntry.details = newRichText(@val[1], @sourceFileInfo[1],
                                          rtTokenSetMore)
    })
    doc('details', <<'EOT'
This is a continuation of the [[summary]] of the journal or status entry. It
can be several paragraphs long.
EOT
       )
    arg(1, 'text', <<'EOT'
The text will be interpreted as [[Rich_Text_Attributes|Rich Text]]. Only a
subset of the markup is supported for this attribute. You can use word
formatting, paragraphs, hyperlinks, lists, section and subsection
headers.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 999
def rule_durationUnit
  pattern(%w( _min ), lambda { 0 })
  descr('minutes')

  pattern(%w( _h ), lambda { 1 })
  descr('hours')

  pattern(%w( _d ), lambda { 2 })
  descr('days')

  pattern(%w( _w ), lambda { 3 })
  descr('weeks')

  pattern(%w( _m ), lambda { 4 })
  descr('months')

  pattern(%w( _y ), lambda { 5 })
  descr('years')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1019
def rule_durationUnitOrPercent
  pattern(%w( _% ), lambda { -1 })
  descr('percentage of reported period')

  pattern(%w( _min ), lambda { 0 })
  descr('minutes')

  pattern(%w( _h ), lambda { 1 })
  descr('hours')

  pattern(%w( _d ), lambda { 2 })
  descr('days')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1033
def rule_dynamicAttributes
  pattern(%w( !reportAttributes . ))
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1037
  def rule_export
    pattern(%w( !exportHeader !exportBody ), lambda {
      @property = @property.parent
    })
    doc('export', <<'EOT'
The export report looks like a regular TaskJuggler file with the provided
input data complemented by the results of the scheduling process. The content
of the report can be controlled with the [[definitions]] attribute. In case
the file contains the project header, a ''''.tjp'''' extension is added to the
file name. Otherwise, a ''''.tji'''' extension is used.

The [[resourceattributes]] and [[taskattributes]] attributes provide even more
control over the content of the file.

The export report can be used to share certain tasks or milestones with other
projects or to save past resource allocations as immutable part for future
scheduling runs. When an export report is included the project IDs of the
included tasks must be declared first with the project id property.
EOT
       )
    example('Export')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1060
  def rule_exportAttributes
    optional
    repeatable

    pattern(%w( _definitions !exportDefinitions ), lambda {
      @property.set('definitions', @val[1])
    })
    doc('definitions', <<"EOT"
This attribute controls what definitions will be contained in the report. If
the list includes ''project'', the generated file will have a ''''.tjp''''
extension. Otherwise it will have a ''''.tji'''' extension.

By default, the report contains everything and the generated files have a ''''.tjp'''' extension.
EOT
       )
    allOrNothingListRule('exportDefinitions',
                         { 'flags' => 'Include flag definitions',
                           'project' => 'Include project header',
                           'projecids' => 'Include project IDs',
                           'tasks' => 'Include task definitions',
                           'resources' => 'Include resource definitions' })

    pattern(%w( _formats !exportFormats ), lambda {
      @property.set('formats', @val[1])
    })
    level(:beta)
    doc('formats.export', <<'EOT'
This attribute defines for which output formats the export report should be
generated. By default, the TJP format will be used.
EOT
       )

    pattern(%w( !hideresource ))
    pattern(%w( !hidetask ))

    pattern(%w( !loadunit ))

    pattern(%w( !purge ))
    pattern(%w( !reportEnd ))
    pattern(%w( !reportPeriod ))
    pattern(%w( !reports ))
    pattern(%w( !reportStart ))

    pattern(%w( _resourceattributes !exportableResourceAttributes ), lambda {
      @property.set('resourceAttributes', @val[1])
    })
    doc('resourceattributes', <<"EOT"
Define a list of resource attributes that should be included in the report.
EOT
       )
    allOrNothingListRule('exportableResourceAttributes',
                         { 'booking' => 'Include bookings',
                           'leaves' => 'Include leaves',
                           'workinghours' => 'Include working hours' })

    pattern(%w( !rollupresource ))
    pattern(%w( !rolluptask ))

    pattern(%w( _scenarios !scenarioIdList ), lambda {
      # Don't include disabled scenarios in the report
      @val[1].delete_if { |sc| !@project.scenario(sc).get('active') }
      @property.set('scenarios', @val[1])
    })
    doc('scenarios.export', <<'EOT'
List of scenarios that should be included in the report. By default, all
scenarios will be included. This attribute can be used to limit the included
scenarios to a defined list.
EOT
       )

    pattern(%w( _taskattributes !exportableTaskAttributes ), lambda {
      @property.set('taskAttributes', @val[1])
    })
    doc('taskattributes', <<"EOT"
Define a list of task attributes that should be included in the report.
EOT
       )
    allOrNothingListRule('exportableTaskAttributes',
                         { 'booking' => 'Include bookings',
                           'complete' => 'Include completion values',
                           'depends' => 'Include dependencies',
                           'flags' => 'Include flags',
                           'maxend' => 'Include maximum end dates',
                           'maxstart' => 'Include maximum start dates',
                           'minend' =>  'Include minimum end dates',
                           'minstart' => 'Include minimum start dates',
                           'note' => 'Include notes',
                           'priority' => 'Include priorities',
                           'responsible' => 'Include responsible resource' })

    pattern(%w( _taskroot !taskId), lambda {
      if @val[1].leaf?
        error('taskroot_leaf',
              "#{@val[1].fullId} is not a container task",
              @sourceFileInfo[1])
      end
      @property.set('taskroot', @val[1])
    })
    level(:experimental)
    doc('taskroot.export', <<'EOT'
Only tasks below the specified root-level tasks are exported. The exported
tasks will have the ID of the root-level task stripped from their ID, so that
the sub-tasks of the root-level task become top-level tasks in the report
file.
EOT
       )
    example('TaskRoot')

    pattern(%w( _timezone !validTimeZone ), lambda {
      @property.set('timezone', @val[1])
    })
    doc('timezone.export',
        "Set the time zone to be used for all dates in the report.")
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1175
def rule_exportBody
  optionsRule('exportAttributes')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1179
  def rule_exportFormat
    pattern(%w( _tjp ), lambda {
      :tjp
    })
    descr('Export of the scheduled project in TJP syntax.')

    pattern(%w( _mspxml ), lambda {
      :mspxml
    })
    descr(<<'EOT'
Export of the scheduled project in Microsoft Project XML format. This will
export the data of the fully scheduled project. The exported data include the
tasks, resources and the assignments of resources to tasks. This is only a
small subset of the data that TaskJuggler can manage. This export is intended
to share resource assignment data with other teams using Microsoft Project.
TaskJuggler manages assignments with a larger accuracy than the Microsoft
Project XML format can represent. This will inevitably lead to some rounding
errors and different interpretation of the data. The numbers you will see in
Microsoft Project are not necessarily an exact match of the numbers you see in
TaskJuggler. The XML file format requires the sequence of the tasks in the
file to follow the work breakdown structure. Hence all user provided sorting
directions will be ignored for this format.
EOT
         )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1205
def rule_exportFormats
  pattern(%w( !exportFormat !moreExportFormats ), lambda {
    [ @val[0] ] + (@val[1].nil? ? [] : @val[1])
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1211
  def rule_exportHeader
    pattern(%w( _export !optionalID $STRING ), lambda {
      newReport(@val[1], @val[2], :export, @sourceFileInfo[0]) do
        unless @property.modified?('formats')
          @property.set('formats', [ :tjp ])
        end

        # By default, we export all scenarios.
        unless @property.modified?('scenarios')
          scenarios = Array.new(@project.scenarios.items) { |i| i }
          scenarios.delete_if { |sc| !@project.scenario(sc).get('active') }
          @property.set('scenarios', scenarios)
        end
        # Show all tasks, sorted by seqno-up.
        unless @property.modified?('hideTask')
          @property.set('hideTask',
                        LogicalExpression.new(LogicalOperation.new(0)))
        end
        unless @property.modified?('sortTasks')
          @property.set('sortTasks', [ [ 'seqno', true, -1 ] ])
        end
        # Show all resources, sorted by seqno-up.
        unless @property.modified?('hideResource')
          @property.set('hideResource',
                        LogicalExpression.new(LogicalOperation.new(0)))
        end
        unless @property.modified?('sortResources')
          @property.set('sortResources', [ [ 'seqno', true, -1 ] ])
        end
      end
    })
    arg(2, 'file name', <<'EOT'
The name of the report file to generate. It must end with a .tjp or .tji
extension, or use . to use the standard output channel.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1249
  def rule_extendAttributes
    optional
    repeatable

    pattern(%w( _date !extendId  $STRING !extendOptionsBody ), lambda {
      # Extend the propertySet definition and parser rules
      if extendPropertySetDefinition(DateAttribute, nil)
        @ruleToExtendWithScenario.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '!date' ], lambda {
            @property[@val[0], @scenarioIdx] = @val[1]
          }))
      else
        @ruleToExtend.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '!date' ], lambda {
            @property.set(@val[0], @val[1])
          }))
      end
    })
    doc('date.extend', <<'EOT'
Extend the property with a new attribute of type date.
EOT
       )
    arg(2, 'name', 'The name of the new attribute. It is used as header ' +
                   'in report columns and the like.')

    pattern(%w( _number !extendId  $STRING !extendOptionsBody ), lambda {
      # Extend the propertySet definition and parser rules
      if extendPropertySetDefinition(FloatAttribute, nil)
        @ruleToExtendWithScenario.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '!number' ], lambda {
            @property[@val[0], @scenarioIdx] = @val[1]
          }))
      else
        @ruleToExtend.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '!number' ], lambda {
            @property.set(@val[0], @val[1])
          }))
      end
    })
    doc('number.extend', <<'EOT'
Extend the property with a new attribute of type number. Possible values for
this attribute could be integer or floating point numbers.
EOT
       )
    arg(2, 'name', 'The name of the new attribute. It is used as header ' +
                   'in report columns and the like.')

    pattern(%w( _reference !extendId $STRING !extendOptionsBody ), lambda {
      # Extend the propertySet definition and parser rules
      if extendPropertySetDefinition(ReferenceAttribute, nil)
        @ruleToExtendWithScenario.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '$STRING', '!referenceBody' ], lambda {
            @property[@val[0], @scenarioIdx] = [ @val[1], @val[2] ]
          }))
      else
        @ruleToExtend.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '$STRING', '!referenceBody' ], lambda {
            @property.set(@val[0], [ @val[1], @val[2] ])
          }))
      end
    })
    doc('reference.extend', <<'EOT'
Extend the property with a new attribute of type reference. A reference is a
URL and an optional text that will be shown instead of the URL if needed.
EOT
       )
    arg(2, 'name', 'The name of the new attribute. It is used as header ' +
                   'in report columns and the like.')

    pattern(%w( _richtext !extendId $STRING !extendOptionsBody ), lambda {
      # Extend the propertySet definition and parser rules
      if extendPropertySetDefinition(RichTextAttribute, nil)
        @ruleToExtendWithScenario.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '$STRING' ], lambda {
            @property[@val[0], @scenarioIdx] =
              newRichText(@val[1], @sourceFileInfo[1])
          }))
      else
        @ruleToExtend.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '$STRING' ], lambda {
            @property.set(@val[0], newRichText(@val[1], @sourceFileInfo[1]))
          }))
      end
    })
    doc('richtext.extend', <<'EOT'
Extend the property with a new attribute of type [[Rich_Text_Attributes|Rich
Text]].
EOT
       )
    arg(2, 'name', 'The name of the new attribute. It is used as header ' +
                   'in report columns and the like.')

    pattern(%w( _text !extendId $STRING !extendOptionsBody ), lambda {
      # Extend the propertySet definition and parser rules
      if extendPropertySetDefinition(StringAttribute, nil)
        @ruleToExtendWithScenario.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '$STRING' ], lambda {
            @property[@val[0], @scenarioIdx] = @val[1]
          }))
      else
        @ruleToExtend.addPattern(TextParser::Pattern.new(
          [ '_' + @val[1], '$STRING' ], lambda {
            @property.set(@val[0], @val[1])
          }))
      end
    })
    doc('text.extend', <<'EOT'
Extend the property with a new attribute of type text. A text is a character
sequence enclosed in single or double quotes.
EOT
       )
    arg(2, 'name', 'The name of the new attribute. It is used as header ' +
                   'in report columns and the like.')

  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1365
def rule_extendBody
  optionsRule('extendAttributes')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1369
def rule_extendId
  pattern(%w( $ID ), lambda {
    unless (?A..?Z) === @val[0][0]
      error('extend_id_cap',
            "User defined attributes IDs must start with a capital letter",
            @sourceFileInfo[0])
    end
    @val[0]
  })
  arg(0, 'id', 'The ID of the new attribute. It can be used like the ' +
               'built-in IDs.')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1382
  def rule_extendOptions
    optional
    repeatable

    singlePattern('_inherit')
    doc('inherit.extend', <<'EOT'
If this attribute is used, the property extension will be inherited by
child properties from their parent property.
EOT
       )

    singlePattern('_scenariospecific')
    doc('scenariospecific.extend', <<'EOT'
If this attribute is used, the property extension is scenario specific. A
different value can be set for each scenario.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1401
def rule_extendOptionsBody
  optionsRule('extendOptions')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1405
def rule_extendProperty
  pattern(%w( !extendPropertyId ), lambda {
    case @val[0]
    when 'task'
      @ruleToExtend = @rules[:taskAttributes]
      @ruleToExtendWithScenario = @rules[:taskScenarioAttributes]
      @propertySet = @project.tasks
    when 'resource'
      @ruleToExtend = @rules[:resourceAttributes]
      @ruleToExtendWithScenario = @rules[:resourceScenarioAttributes]
      @propertySet = @project.resources
    end
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1420
def rule_extendPropertyId
  singlePattern('_task')
  singlePattern('_resource')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1425
  def rule_fail
    pattern(%w( _fail !logicalExpression ), lambda {
      begin
        @property.set('fail', @property.get('fail') + [ @val[1] ])
      rescue AttributeOverwrite
      end
    })
    doc('fail', <<'EOT'
The fail attribute adds a [[logicalexpression|logical expression]] to the
property. The condition described by the logical expression is checked after
the scheduling and an error is raised if the condition evaluates to true. This
attribute is primarily intended for testing purposes.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1441
def rule_flag
  pattern(%w( $ID ), lambda {
    unless @project['flags'].include?(@val[0])
      error('undecl_flag', "Undeclared flag '#{@val[0]}'",
            @sourceFileInfo[0])
    end
    @val[0]
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1555
def rule_flagList
  listRule('moreFlagList', '!flag')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1451
  def rule_flagLogicalExpression
    pattern(%w( !flagOperation ), lambda {
      LogicalExpression.new(@val[0], sourceFileInfo)
    })
    doc('logicalflagexpression', <<'EOT'
A logical flag expression is a combination of operands and mathematical
operations.  The final result of a logical expression is always true or false.
Logical expressions are used the reduce the properties in a report to a
certain subset or to select alternatives for the cell content of a table. When
the logical expression is used with attributes like [[hidejournalentry]] and
evaluates to true for a certain property, this property is hidden or rolled-up
in the report.

Operands must be previously declared flags or another logical expression.
When you combine logical operations to a more complex expression, the
operators are evaluated from left to right. '''a | b & c''' is identical to
'''(a | b) & c'''. It's highly recommended that you always use brackets to
control the evaluation sequence. Currently, TaskJuggler does not support the
concept of operator precedence or right-left associativity. This may change in
the future.
EOT
       )
    also(%w( functions ))
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1476
def rule_flagOperand
  pattern(%w( _( !flagOperation _) ), lambda {
    @val[1]
  })
  pattern(%w( _~ !flagOperand ), lambda {
    operation = LogicalOperation.new(@val[1])
    operation.operator = '~'
    operation
  })

  pattern(%w( $ID ), lambda {
    unless @project['flags'].include?(@val[0])
      error('operand_unkn_flag', "Undeclared flag '#{@val[0]}'",
            @sourceFileInfo[0])
    end
    LogicalFlag.new(@val[0])
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1495
  def rule_flagOperation
    pattern(%w( !flagOperand !flagOperationChain ), lambda {
      operation = LogicalOperation.new(@val[0])
      if @val[1]
        # Further operators/operands create an operation tree.
        @val[1].each do |ops|
          operation = LogicalOperation.new(operation)
          operation.operator = ops[0]
          operation.operand2 = ops[1]
        end
      end
      operation
    })
    arg(0, 'operand', <<'EOT'
An operand is a declared flag. An operand can be a negated operand by
prefixing a ~ character or it can be another logical expression enclosed in
braces.
EOT
        )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1516
def rule_flagOperationChain
  optional
  repeatable
  pattern(%w( !flagOperatorAndOperand), lambda {
    @val[0]
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1536
def rule_flagOperator
  singlePattern('_|')
  descr('The \'or\' operator')

  singlePattern('_&')
  descr('The \'and\' operator')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1524
  def rule_flagOperatorAndOperand
    pattern(%w( !flagOperator !flagOperand), lambda{
      [ @val[0], @val[1] ]
    })
    arg(1, 'operand', <<'EOT'
An operand is a declared flag. An operand can be a negated operand by
prefixing a ~ character or it can be another logical expression enclosed in
braces.
EOT
        )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1545
def rule_flags
  pattern(%w( _flags !flagList ), lambda {
    @val[1].each do |flag|
      next if @property['flags', @scenarioIdx].include?(flag)

      @property['flags', @scenarioIdx] += [ flag ]
    end
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1559
  def rule_formats
    pattern(%w( _formats !outputFormats ), lambda {
      @property.set('formats', @val[1])
    })
    doc('formats', <<'EOT'
This attribute defines for which output formats the report should be
generated. By default, this list is empty. Unless a formats attribute was
added to a report definition, no output will be generated for this report.

As reports are composable, a report may include other report definitions. A
format definition is only needed for the outermost report that includes the
others.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1620
  def rule_functionPatterns
    # This rule is not used by the parser. It's only for the documentation.
    pattern(%w( _hasalert _( $INTEGER _, !date _) ))
    doc('hasalert', <<'EOT'
Will evaluate to true if the current property has a current alert message within the report time frame and with at least the provided alert level.
EOT
       )
    arg(2, 'Level', 'The minimum required alert level to be considered.')

    pattern(%w( _isactive _( $ID _) ))
    doc('isactive', <<'EOT'
Will evaluate to true for tasks and resources if they have bookings in
the scenario during the report time frame.
EOT
       )
    arg(2, 'ID', 'A scenario ID')

    pattern(%w( _ischildof _( $ID _) ))
    doc('ischildof', <<'EOT'
Will evaluate to true for tasks and resources if current property is a child
of the provided parent property.
EOT
       )
    arg(2, 'ID', 'The ID of the parent')

    pattern(%w( _isdependencyof _( $ID _, $ID _, $INTEGER _) ))
    doc('isdependencyof', <<'EOT'
Will evaluate to true for tasks that depend on the specified task in
the specified scenario and are no more than distance tasks away. If
distance is 0, all dependencies are considered independent of their
distance.
EOT
       )
    arg(2, 'Task ID', 'The ID of a defined task')
    arg(4, 'Scenario ID', 'A scenario ID')
    arg(6, 'Distance', 'The maximum task distance to be considered')

    pattern(%w( _isdutyof _( $ID _, $ID _) ))
    doc('isdutyof', <<'EOT'
Will evaluate to true for tasks that have the specified resource
assigned to it in the specified scenario.
EOT
       )
    arg(2, 'Resource ID', 'The ID of a defined resource')
    arg(4, 'Scenario ID', 'A scenario ID')

    pattern(%w( _isfeatureof _( $ID _, $ID _) ))
    doc('isfeatureof', <<'EOT'
If the provided task or any of its sub-tasks depend on this task or any of its
sub-tasks, we call this task a feature of the provided task.
EOT
       )
    arg(2, 'Task ID', 'The ID of a defined task')
    arg(4, 'Scenario ID', 'A scenario ID')

    pattern(['_isleaf', '_(', '_)' ])
    doc('isleaf', 'The result is true if the property is not a container.')

    pattern(%w( _ismilestone _( $ID _) ))
    doc('ismilestone', <<'EOT'
The result is true if the property is a milestone in the provided scenario.
EOT
       )
    arg(2, 'Scenario ID', 'A scenario ID')

    pattern(%w( _isongoing _( $ID _) ))
    doc('isongoing', <<'EOT'
Will evaluate to true for tasks that overlap with the report period in the given
scenario.
EOT
       )
    arg(2, 'ID', 'A scenario ID')

    pattern(['_isresource', '_(', '_)' ])
    doc('isresource', 'The result is true if the property is a resource.')

    pattern(%w( _isresponsibilityof _( $ID _, $ID _) ))
    doc('isresponsibilityof', <<'EOT'
Will evaluate to true for tasks that have the specified resource
assigned as [[responsible]] in the specified scenario.
EOT
       )
    arg(2, 'Resource ID', 'The ID of a defined resource')
    arg(4, 'Scenario ID', 'A scenario ID')

    pattern(['_istask', '_(', '_)' ])
    doc('istask', 'The result is true if the property is a task.')

    pattern(%w( _isvalid _( $ID _) ))
    doc('isvalid', 'Returns false if argument is not an assigned or ' +
                   'properly computed value.')

    pattern(%w( _treelevel _( _) ))
    doc('treelevel', <<'EOT'
Returns the nesting level of a property in the property tree.
Top level properties have a level of 1, their children 2 and so on.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1575
  def rule_functions
    # This rule is not used by the parser. It's only for the documentation.
    pattern(%w( !functionsBody ))
    doc('functions', <<'EOT'
The following functions are supported in logical expressions. These functions
are evaluated in logical conditions such as hidetask or rollupresource. For
the evaluation, implicit and explicit parameters are used.

All functions may operate on the current property and the scope property. The
scope property is the enclosing property in reports with nested properties.
Imagine e. g. a task report with nested resources. When the function is called
for a task line, the task is the property and we don't have a scope property.
When the function is called for a resource line, the resource is the property
and the enclosing task is the scope property.

The number of arguments that are passed in brackets to the function depends
on the specific function. See the reference for details on each function.

All functions can be suffixed with an underscore character. In that case, the
function is operating on the scope property as if it were the property. The
original property is ignored in that case. In our task report example from
above, calling a function with an appended underscore would mean that a task
line would be evaluated for the enclosing resource.

In the example below you can see how this can be used. To generate a task
report that lists all assigned leaf resources for leaf task lines only we use
the expression

 hideresource ~(isleaf() & isleaf_())

The tilde in front of the bracketed expression means not that expression. In
other words: show resources that are leaf resources and show them for leaf
tasks only. The regular form isleaf() (without the appended underscore)
operates on the resource. The isleaf_() variant operates on the
enclosing task.
EOT
       )
    example('LogicalFunction', '1')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1615
def rule_functionsBody
  # This rule is not used by the parser. It's only for the documentation.
  optionsRule('functionPatterns')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1720
def rule_hAlignment
  pattern(%w( _center ), lambda {
    :center
  })
  doc('halign.center', 'Center the cell content')

  pattern(%w( _left ), lambda {
    :left
  })
  doc('halign.left', 'Left align the cell content')

  pattern(%w( _right ), lambda {
    :right
  })
  doc('halign.right', 'Right align the cell content')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1737
  def rule_headline
    pattern(%w( _headline $STRING ), lambda {
      @property.set('headline', newRichText(@val[1], @sourceFileInfo[1]))
    })
    doc('headline', <<'EOT'
Specifies the headline for a report.
EOT
       )
    arg(1, 'text', <<'EOT'
The text used for the headline. It is interpreted as
[[Rich_Text_Attributes|Rich Text]].
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1752
  def rule_hideaccount
    pattern(%w( _hideaccount !logicalExpression ), lambda {
      @property.set('hideAccount', @val[1])
    })
    doc('hideaccount', <<'EOT'
Do not include accounts that match the specified [[logicalexpression|logical
expression]]. If the report is sorted in ''''tree'''' mode (default) then
enclosing accounts are
listed even if the expression matches the account.
EOT
       )
    also(%w( sortaccounts ))
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1766
  def rule_hidejournalentry
    pattern(%w( _hidejournalentry !flagLogicalExpression ), lambda {
      @property.set('hideJournalEntry', @val[1])
    })
    doc('hidejournalentry', <<'EOT'
Do not include journal entries that match the specified logical expression.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1776
  def rule_hideresource
    pattern(%w( _hideresource !logicalExpression ), lambda {
      @property.set('hideResource', @val[1])
    })
    doc('hideresource', <<'EOT'
Do not include resources that match the specified [[logicalexpression|logical
expression]]. If the report is sorted in ''''tree'''' mode (default) then
enclosing resources are listed even if the expression matches the resource.
EOT
       )
    also(%w( sortresources ))
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1789
  def rule_hidetask
    pattern(%w( _hidetask !logicalExpression ), lambda {
      @property.set('hideTask', @val[1])
    })
    doc('hidetask', <<'EOT'
Do not include tasks that match the specified [[logicalexpression|logical
expression]]. If the report is sorted in ''''tree'''' mode (default) then
enclosing tasks are listed even if the expression matches the task.
EOT
       )
    also(%w( sorttasks ))
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1801
  def rule_iCalReport
    pattern(%w( !iCalReportHeader !iCalReportBody ), lambda {
      @property = nil
    })
    doc('icalreport', <<'EOT'
Generates an RFC5545 compliant iCalendar file. This file can be used to export
task information to calendar applications or other tools that read iCalendar
files.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1816
  def rule_iCalReportAttributes
    optional
    repeatable

    pattern(%w( !hideresource ))
    pattern(%w( !hidejournalentry ))
    pattern(%w( !hidetask ))
    pattern(%w( !reportEnd ))
    pattern(%w( !reportPeriod ))
    pattern(%w( !reportStart ))
    pattern(%w( !rollupresource ))
    pattern(%w( !rolluptask ))
    pattern(%w( _novevents), lambda { @property.set('novevents', [ true ]) })
    doc('novevents', <<'EOT'
Don't add VEVENT entries to generated [[icalreport]]s.
EOT
    )

    pattern(%w( _scenario !scenarioId ), lambda {
      # Don't include disabled scenarios in the report
      sc = @val[1]
      unless @project.scenario(sc).get('active')
        warning('ical_sc_disabled',
                "Scenario #{sc} has been disabled")
      else
        @property.set('scenarios', [ @val[1] ])
      end
    })
    doc('scenario.ical', <<'EOT'
ID of the scenario that should be included in the report. By default, the
top-level scenario will be included. This attribute can be used to select another
scenario.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1812
def rule_iCalReportBody
  optionsRule('iCalReportAttributes')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1852
  def rule_iCalReportHeader
    pattern(%w( _icalreport !optionalID $STRING ), lambda {
      newReport(@val[1], @val[2], :iCal, @sourceFileInfo[0]) do
        @property.set('formats', [ :iCal ])

        # By default, we export only the first scenario.
        unless @project.scenario(0).get('active')
          @property.set('scenarios', [ 0 ])
        end
        # Show all tasks, sorted by seqno-up.
        @property.set('hideTask', LogicalExpression.new(LogicalOperation.new(0)))
        @property.set('sortTasks', [ [ 'seqno', true, -1 ] ])
        # Show all resources, sorted by seqno-up.
        @property.set('hideResource',
                      LogicalExpression.new(LogicalOperation.new(0)))
        @property.set('sortResources', [ [ 'seqno', true, -1 ] ])
        # Show all journal entries.
        @property.set('hideJournalEntry',
                      LogicalExpression.new(LogicalOperation.new(0)))
        # Add VEVENT entries to icalreports by default
        @property.set('novevents', [ false ])
      end
    })
    arg(1, 'file name', <<'EOT'
The name of the report file to generate without an extension.  Use . to use
the standard output channel.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1882
def rule_idOrAbsoluteId
  singlePattern('$ID')
  singlePattern('$ABSOLUTE_ID')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1887
def rule_includeAttributes
  optionsRule('includeAttributesBody')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1891
  def rule_includeAttributesBody
    optional
    repeatable

    pattern(%w( _accountprefix !accountId ), lambda {
      @accountprefix = @val[1].fullId
    })
    doc('accountprefix', <<'EOT'
This attribute can be used to insert the accounts of the included file as
sub-account of the account specified by ID. The parent account must already be
defined.
EOT
    )
    arg(1, 'account ID', 'The absolute ID of an already defined account')

    pattern(%w( _reportprefix !reportId ), lambda {
      @reportprefix = @val[1].fullId
    })
    doc('reportprefix', <<'EOT'
This attribute can be used to insert the reports of the included file as
sub-report of the report specified by ID. The parent report must already
be defined.
EOT
    )
    arg(1, 'report ID', 'The absolute ID of an already defined report.')

    pattern(%w( _resourceprefix !resourceId ), lambda {
      @resourceprefix = @val[1].fullId
    })
    doc('resourceprefix', <<'EOT'
This attribute can be used to insert the resources of the included file as
sub-resource of the resource specified by ID. The parent resource must already
be defined.
EOT
    )
    arg(1, 'resource ID', 'The ID of an already defined resource')

    pattern(%w( _taskprefix !taskId ), lambda {
      @taskprefix = @val[1].fullId
    })
    doc('taskprefix', <<'EOT'
This attribute can be used to insert the tasks of the included file as
sub-task of the task specified by ID. The parent task must already be defined.
EOT
    )
    arg(1, 'task ID', 'The absolute ID of an already defined task.')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1939
def rule_includeFile
  pattern(%w( !includeFileName ), lambda {
    unless @project
      error('include_before_project',
            "You must declare the project header before you include other " +
            "files.")
    end
    @project.inputFiles << @scanner.include(@val[0], @sourceFileInfo[0]) do
      popFileStack
    end
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1952
  def rule_includeFileName
    pattern(%w( $STRING ), lambda {
      unless @val[0][-4, 4] == '.tji'
        error('bad_include_suffix', "Included files must have a '.tji'" +
                                    "extension: '#{@val[0]}'",
              @sourceFileInfo[0])
      end
      pushFileStack
      @val[0]
    })
    arg(0, 'filename', <<'EOT'
Name of the file to include. This must have a ''''.tji'''' extension. The name
may have an absolute or relative path. You need to use ''''/'''' characters to
separate directories.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1970
def rule_includeProperties
  pattern(%w( !includeFileName !includeAttributes ), lambda {
    @project.inputFiles << @scanner.include(@val[0], @sourceFileInfo[0]) do
      popFileStack
    end
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2010
  def rule_interval
    pattern(%w( !date !intervalEnd ), lambda {
      mode = @val[1][0]
      endSpec = @val[1][1]
      if mode == 0
        unless @val[0] < endSpec
          error('start_before_end', "The end date (#{endSpec}) must be after " +
                "the start date (#{@val[0]}).", @sourceFileInfo[0])
        end
        TimeInterval.new(@val[0], endSpec)
      else
        TimeInterval.new(@val[0], @val[0] + endSpec)
      end
    })
    doc('interval2', <<'EOT'
There are two ways to specify a date interval. The first is the most
obvious. A date interval consists of a start and end DATE. Watch out for end
dates without a time specification! Date specifications are 0 extended. An
end date without a time is expanded to midnight that day. So the day of the
end date is not included in the interval! The start and end dates must be separated by a hyphen character.

The second form specifies the start date and an interval duration. The
duration must be prefixed by a plus character.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2037
def rule_intervalDuration
  pattern(%w( !number !durationUnit ), lambda {
    convFactors = [ 60, # minutes
                    60 * 60, # hours
                    60 * 60 * 24, # days
                    60 * 60 * 24 * 7, # weeks
                    60 * 60 * 24 * 30.4167, # months
                    60 * 60 * 24 * 365 # years
                   ]
    if @val[0] == 0.0
      error('zero_duration', "The interval duration may not be 0.",
            @sourceFileInfo[1])
    end
    duration = (@val[0] * convFactors[@val[1]]).to_i
    resolution = @project.nil? ? 60 * 60 : @project['scheduleGranularity']
    if @val[1] == 4
      # If the duration unit is months, we have to align the duration with
      # the timing resolution of the project.
      duration = (duration / resolution).to_i * resolution
    end
    # Make sure the interval aligns with the timing resolution.
    if duration % resolution != 0
      error('iv_duration_not_aligned',
            "The interval duration must be a multiple of the specified " +
            "timing resolution (#{resolution / 60} min) of the project.")
    end
    duration
  })
  arg(0, 'duration', 'The duration of the interval. May not be 0 and must ' +
                     'be a multiple of [[timingresolution]].')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2069
def rule_intervalEnd
  pattern([ '_-', '!date' ], lambda {
    [ 0, @val[1] ]
  })

  pattern(%w( _+ !intervalDuration ), lambda {
    [ 1, @val[1] ]
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2094
def rule_intervalOptional
  optional
  singlePattern('!interval')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2079
def rule_intervalOptionalEnd
  optional
  pattern([ '_-', '!date' ], lambda {
    [ 0, @val[1] ]
  })

  pattern(%w( _+ !intervalDuration ), lambda {
    [ 1, @val[1] ]
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 1978
  def rule_intervalOrDate
    pattern(%w( !date !intervalOptionalEnd ), lambda {
      if @val[1]
        mode = @val[1][0]
        endSpec = @val[1][1]
        if mode == 0
          unless @val[0] < endSpec
            error('start_before_end', "The end date (#{endSpec}) must be " +
                  "after the start date (#{@val[0]}).", @sourceFileInfo[0])
          end
          TimeInterval.new(@val[0], endSpec)
        else
          TimeInterval.new(@val[0], @val[0] + endSpec)
        end
      else
        TimeInterval.new(@val[0], @val[0].sameTimeNextDay)
      end
    })
    doc('interval3', <<'EOT'
There are three ways to specify a date interval. The first is the most
obvious. A date interval consists of a start and end DATE. Watch out for end
dates without a time specification! Date specifications are 0 extended. An
end date without a time is expanded to midnight that day. So the day of the
end date is not included in the interval! The start and end dates must be separated by a hyphen character.

In the second form, the end date is omitted. A 24 hour interval is assumed.

The third form specifies the start date and an interval duration. The duration must be prefixed by a plus character.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2090
def rule_intervals
  listRule('moreIntervals', '!intervalOrDate')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2099
def rule_intervalsOptional
  optional
  singlePattern('!intervals')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2190
  def rule_journalEntry
    pattern(%w( !journalEntryHeader !journalEntryBody ), lambda {
      @val[0]
    })
    doc('journalentry', <<'EOT'
This attribute adds an entry to the journal of the project. A journal can be
used to record events, decisions or news that happened at a particular moment
during the project. Depending on the context, a journal entry may or may not
be associated with a specific property or author.

A journal entry can consist of up to three parts. The headline is mandatory
and should be only 5 to 10 words long. The introduction is optional and should
be only one or two sentences long. All other details should be put into the
third part.

Depending on the context, journal entries are listed with headlines only, as
headlines plus introduction or in full.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2211
  def rule_journalEntryAttributes
    optional
    repeatable

    pattern(%w( _alert !alertLevel ), lambda {
      @journalEntry.alertLevel = @val[1]
    })
    doc('alert', <<'EOT'
Specify the alert level for this entry. This attribute is intended to be used for
status reporting. When used for a journal entry that is associated with a
property, the value can be reported in the alert column. When multiple entries
have been specified for the property, the entry with the date closest to the
report end date will be used. Container properties will inherit the highest
alert level of all its sub properties unless it has an own journal entry dated
closer to the report end than all of its sub properties.
EOT
       )

    pattern(%w( !author ))

    pattern(%w( _flags !flagList ), lambda {
      @val[1].each do |flag|
        next if @journalEntry.flags.include?(flag)

        @journalEntry.flags << flag
      end
    })
    doc('flags.journalentry', <<'EOT'
Journal entries can have flags attached to them. These can be used to
include only entries in a report that have a certain flag.
EOT
       )

    pattern(%w( !summary ))

    pattern(%w( !details ))
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2249
def rule_journalEntryBody
  optionsRule('journalEntryAttributes')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2253
  def rule_journalEntryHeader
    pattern(%w( _journalentry !valDate $STRING ), lambda {
      @journalEntry = JournalEntry.new(@project['journal'], @val[1], @val[2],
                                       @property, @sourceFileInfo[0])
    })
    arg(2, 'headline', <<'EOT'
The headline of the journal entry. It will be interpreted as
[[Rich_Text_Attributes|Rich Text]].
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2104
  def rule_journalReportAttributes
    pattern(%w( _journalattributes !journalReportAttributesList ), lambda {
      @property.set('journalAttributes', @val[1])
    })
    doc('journalattributes', <<'EOT'
A list that determines which of the journal attributes should be included in
the journal report.
EOT
       )
    allOrNothingListRule('journalReportAttributesList',
                         { 'alert' => 'Include the alert status',
                           'author' => 'Include the author if known',
                           'date' => 'Include the date',
                           'details' => 'Include the details',
                           'flags' => 'Include the flags',
                           'headline' => 'Include the headline',
                           'property' => 'Include the task or resource name',
                           'propertyid' => 'Include the property ID. ' +
                                           'Requires \'property\'.',
                           'summary' => 'Include the summary',
                           'timesheet' => 'Include the timesheet information.' +
                                          ' Requires \'property\'.'})
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2128
  def rule_journalReportMode
    pattern(%w( _journal ), lambda { :journal })
    descr(<<'EOT'
This is the regular journal. It contains all journal entries that are dated in
the query interval. If a property is given, only entries of this property are
included. Without a property context, all the project entries are included
unless hidden by other attributes like [[hidejournalentry]].
EOT
       )
    pattern(%w( _journal_sub ), lambda { :journal_sub })
    descr(<<'EOT'
This mode only yields entries if used in the context of a task. It contains
all journal entries that are dated in the query interval for the task and all
its sub tasks.
EOT
       )
    pattern(%w( _status_dep ), lambda { :status_dep })
    descr(<<'EOT'
In this mode only the last entries before the report end date for each
property and all its sub-properties and their dependencies are included. If
there are multiple entries at the exact same date, then all these entries are
included.
EOT
       )
    pattern(%w( _status_down ), lambda { :status_down })
    descr(<<'EOT'
In this mode only the last entries before the report end date for each
property and all its sub-properties are included. If there are multiple entries
at the exact same date, then all these entries are included.
EOT
       )
    pattern(%w( _status_up ), lambda { :status_up })
    descr(<<'EOT'
In this mode only the last entries before the report end date for each
property are included. If there are multiple entries at the exact same date,
then all these entries are included. If any of the parent properties has a
more recent entry that is still before the report end date, no entries will be
included.
EOT
       )
    pattern(%w( _alerts_dep ), lambda { :alerts_dep })
    descr(<<'EOT'
In this mode only the last entries before the report end date for the context
property and all its sub-properties and their dependencies are included. If
there are multiple entries at the exact same date, then all these entries are
included. In contrast to the ''''status_down'''' mode, only entries with an
alert level above the default level, and only those with the highest overall
alert level are included.
EOT
       )
    pattern(%w( _alerts_down ), lambda { :alerts_down })
    descr(<<'EOT'
In this mode only the last entries before the report end date for the context
property and all its sub-properties is included. If there are multiple entries
at the exact same date, then all these entries are included. In contrast to
the ''''status_down'''' mode, only entries with an alert level above the
default level, and only those with the highest overall alert level are
included.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2265
def rule_journalSortCriteria
  pattern(%w( !journalSortCriterium !moreJournalSortCriteria ), lambda {
    [ @val[0] ] + (@val[1].nil? ? [] : @val[1])
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2271
def rule_journalSortCriterium
  pattern(%w( $ABSOLUTE_ID ), lambda {
    supported = []
    JournalEntryList::SortingAttributes.each do |attr|
      supported << "#{attr}.up"
      supported << "#{attr}.down"
    end
    unless supported.include?(@val[0])
      error('bad_journal_sort_criterium',
            "Unsupported sorting criterium #{@val[0]}. Must be one of " +
            "#{supported.join(', ')}.")
    end
    attr, direction = @val[0].split('.')
    [ attr.intern, direction == 'up' ? 1 : -1 ]
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2288
def rule_leafResourceId
  pattern(%w( !resourceId ), lambda {
    resource = @val[0]
    unless resource.leaf?
      error('leaf_resource_id_expected',
            "#{resource.id} is not a leaf resource.", @sourceFileInfo[0])
    end
    resource
  })
  arg(0, 'resource', 'The ID of a leaf resource')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2300
def rule_leave
  pattern(%w( !leaveType !vacationName !intervalOrDate ), lambda {
    Leave.new(@val[0].intern, @val[2], @val[1])
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2318
def rule_leaveAllowance
  pattern(%w( _annual !valDate !optionalMinus
              !nonZeroWorkingDuration ), lambda {
    LeaveAllowance.new(:annual, @val[1], (@val[2] ? -1 : 1) * @val[3])
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2325
def rule_leaveAllowanceList
  listRule('moreLeaveAllowanceList', '!leaveAllowance')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2329
  def rule_leaveAllowances
    pattern(%w( _leaveallowances !leaveAllowanceList ), lambda {
      appendScListAttribute('leaveallowances', @val[1])
    })
    doc('leaveallowance', <<'EOT'
Add or subtract leave allowances. Currently, only allowances for the annual
leaves are supported. Allowances can be negative to deal with expired
allowances. The ''''leaveallowancebalance'''' report [[columns|column]] can be
used to report the current annual leave balance.

Leaves outside of the project period are silently ignored and will not be
considered in the leave balance calculation. Therefore, leave allowances are
only allowed within the project period.
EOT
      )
    level(:beta)
    example('Leave')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2306
def rule_leaveList
  listRule('moreLeaveList', '!leave')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2310
def rule_leaveName
  optional
  pattern(%w( $STRING ), lambda {
    @val[0]
  })
  arg(0, 'name', 'An optional name or reason for the leave')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2372
def rule_leaveType
  singlePattern('_project')
  descr('Assignment to another project (lowest priority)')

  singlePattern('_annual')
  descr('Personal leave based on annual allowance')

  singlePattern('_special')
  descr('Personal leave based on a special occasion')

  singlePattern('_sick')
  descr('Sick leave')

  singlePattern('_unpaid')
  descr('Unpaid leave')

  singlePattern('_holiday')
  descr('Public or bank holiday')

  singlePattern('_unemployed')
  descr('Not employeed (highest priority)')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2348
  def rule_leaves
    pattern(%w( _leaves !leaveList ), lambda {
      LeaveList.new(@val[1])
    })
    doc('leaves', <<'EOT'
Describe a list of leave periods. A leave can be due to a public holiday,
personal or sick leave. At global scope, the leaves determine which day is
considered a working day. Subsequent resource definitions will inherit the
leave list.

Leaves can be defined at global level, at resource level and at shift level
and intervals may overlap. The leave types have different priorities. A higher
priority leave type can overwrite a lower priority type. This means that
resource level leaves can overwrite global leaves when they have a higher
priority. A sub resource can overwrite a leave of an enclosing resource.

Leave periods outside of the project interval are silently ignored. For leave
periods that are partially outside of the project period only the part inside
the project period will be considered.
EOT
       )
    example('Leave')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2395
def rule_limitAttributes
  optionsRule('limitAttributesBody')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2399
  def rule_limitAttributesBody
    optional
    repeatable

    pattern(%w( _end !valDate ), lambda {
      @limitInterval.end = @val[1]
    })
    doc('end.limit', <<'EOT'
The end date of the limit interval. It must be within the project time frame.
EOT
    )

    pattern(%w( _period !valInterval ), lambda {
      @limitInterval = ScoreboardInterval.new(@project['start'],
                                              @project['scheduleGranularity'],
                                              @val[1].start, @val[1].end)
    })
    doc('period.limit', <<'EOT'
This property is a shortcut for setting the start and end dates of the limit
interval. Both dates must be within the project time frame.
EOT
       )

    pattern(%w( _resources !resourceLeafList ), lambda {
      @limitResources = @val[1]
    })
    doc('resources.limit', <<'EOT'
When [[limits]] are used in a [[task]] context, the limits can be restricted
to a list of resources that are allocated to the task. In that case each
listed resource will not be allocated more than the specified upper limit.
Lower limits have no impact on the scheduler but do generate a warning when
not met.  All specified resources must be leaf resources.
EOT
       )
    example('Limits-1', '5')

    pattern(%w( _start !valDate ), lambda {
      @limitInterval.start = @val[1]
    })
    doc('start.limit', <<'EOT'
The start date of the limit interval. It must be within the project time frame.
EOT
    )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2444
def rule_limitValue
  pattern([ '!nonZeroWorkingDuration' ], lambda {
    @limitInterval = ScoreboardInterval.new(@project['start'],
                                            @project['scheduleGranularity'],
                                            @project['start'], @project['end'])
    @limitResources = []
    @val[0]
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2454
def rule_limits
  pattern(%w( !limitsHeader !limitsBody ), lambda {
    @val[0]
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2460
  def rule_limitsAttributes
    optional
    repeatable

    pattern(%w( _dailymax !limitValue !limitAttributes), lambda {
      setLimit(@val[0], @val[1], @limitInterval)
    })
    doc('dailymax', <<'EOT'
Set a maximum limit for each calendar day.
EOT
       )
    example('Limits-1', '1')

    pattern(%w( _dailymin !limitValue !limitAttributes), lambda {
      setLimit(@val[0], @val[1], @limitInterval)
    })
    doc('dailymin', <<'EOT'
Minimum required effort for any calendar day. This value cannot be guaranteed by
the scheduler. It is only checked after the schedule is complete. In case the
minimum required amount has not been reached, a warning will be generated.
EOT
       )
    example('Limits-1', '4')

    pattern(%w( _maximum !limitValue !limitAttributes), lambda {
      setLimit(@val[0], @val[1], @limitInterval)
    })
    doc('maximum', <<'EOT'
Set a maximum limit for the specified period. You must ensure that the overall
effort can be achieved!
EOT
       )

    pattern(%w( _minimum !limitValue !limitAttributes), lambda {
      setLimit(@val[0], @val[1], @limitInterval)
    })
    doc('minimum', <<'EOT'
Set a minim limit for each calendar month. This will only result in a warning
if not met.
EOT
       )

    pattern(%w( _monthlymax !limitValue !limitAttributes), lambda {
      setLimit(@val[0], @val[1], @limitInterval)
    })
    doc('monthlymax', <<'EOT'
Set a maximum limit for each calendar month.
EOT
       )

    pattern(%w( _monthlymin !limitValue !limitAttributes), lambda {
      setLimit(@val[0], @val[1], @limitInterval)
    })
    doc('monthlymin', <<'EOT'
Minimum required effort for any calendar month. This value cannot be
guaranteed by the scheduler. It is only checked after the schedule is
complete. In case the minimum required amount has not been reached, a warning
will be generated.
EOT
       )

    pattern(%w( _weeklymax !limitValue !limitAttributes), lambda {
      setLimit(@val[0], @val[1], @limitInterval)
    })
    doc('weeklymax', <<'EOT'
Set a maximum limit for each calendar week.
EOT
       )

    pattern(%w( _weeklymin !limitValue !limitAttributes), lambda {
      setLimit(@val[0], @val[1], @limitInterval)
    })
    doc('weeklymin', <<'EOT'
Minimum required effort for any calendar week. This value cannot be guaranteed by
the scheduler. It is only checked after the schedule is complete. In case the
minimum required amount has not been reached, a warning will be generated.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2540
def rule_limitsBody
  optionsRule('limitsAttributes')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2544
def rule_limitsHeader
  pattern(%w( _limits ), lambda {
    @limits = Limits.new
    @limits.setProject(@project)
    @limits
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2552
def rule_listOfDays
  pattern(%w( !weekDayInterval !moreListOfDays), lambda {
    weekDays = Array.new(7, false)
    ([ @val[0] ] + (@val[1] ? @val[1] : [])).each do |dayList|
      7.times { |i| weekDays[i] = true if dayList[i] }
    end
    weekDays
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2562
def rule_listOfTimes
  pattern(%w( _off ), lambda {
    [ ]
  })
  pattern(%w( !timeInterval !moreTimeIntervals ), lambda {
    [ @val[0] ] + (@val[1].nil? ? [] : @val[1])
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2571
def rule_listType
  pattern([ '_bullets' ], lambda { :bullets })
  descr('List items as bullet list')

  pattern([ '_comma' ], lambda { :comma })
  descr('List items as comma separated list')

  pattern([ '_numbered' ], lambda { :numbered })
  descr('List items as numbered list')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2582
  def rule_loadunit
    pattern(%w( _loadunit !loadunitName ), lambda {
      @property.set('loadUnit', @val[1])
    })
    doc('loadunit', <<'EOT'
Determines what unit should be used to display all load values in this report.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2592
  def rule_loadunitName
    pattern([ '_days' ], lambda { :days })
    descr('Display all load and duration values as days.')

    pattern([ '_hours' ], lambda { :hours })
    descr('Display all load and duration values as hours.')

    pattern([ '_longauto'] , lambda { :longauto })
    descr(<<'EOT'
Automatically select the unit that produces the shortest and most readable
value. The unit name will not be abbreviated. It will not use quarters since
it is not common.
EOT
         )

    pattern([ '_minutes' ], lambda { :minutes })
    descr('Display all load and duration values as minutes.')

    pattern([ '_months' ], lambda { :months })
    descr('Display all load and duration values as months.')

    pattern([ '_quarters' ], lambda { :quarters })
    descr('Display all load and duration values as quarters.')

    pattern([ '_shortauto' ], lambda { :shortauto })
    descr(<<'EOT'
Automatically select the unit that produces the shortest and most readable
value. The unit name will be abbreviated. It will not use quarters since it is
not common.
EOT
         )

    pattern([ '_weeks' ], lambda { :weeks })
    descr('Display all load and duration values as weeks.')

    pattern([ '_years' ], lambda { :years })
    descr('Display all load and duration values as years.')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2631
  def rule_logicalExpression
    pattern(%w( !operation ), lambda {
      LogicalExpression.new(@val[0], sourceFileInfo)
    })
    pattern(%w( _@ !allOrNone ), lambda {
      LogicalExpression.new(LogicalOperation.new(@val[1]), sourceFileInfo)
    })
    doc('logicalexpression', <<'EOT'
A logical expression is a combination of operands and mathematical operations.
The final result of a logical expression is always true or false. Logical
expressions are used the reduce the properties in a report to a certain subset
or to select alternatives for the cell content of a table. When the
logical expression is used with attributes like [[hidetask]] or [[hideresource]] and
evaluates to true for a certain property, this property is hidden or rolled-up
in the report.

Operands can be previously declared flags, built-in [[functions]], property
attributes (specified as scenario.attribute) or another logical expression.
When you combine logical operations to a more complex expression, the
operators are evaluated from left to right. ''''a | b & c'''' is identical to
''''(a | b) & c''''. It's highly recommended that you always use brackets to
control the evaluation sequence. Currently, TaskJuggler does not support the
concept of operator precedence or right-left associativity. This may change in
the future.

An operand can also be just a number. 0 evaluates to false, all other numbers
to true. The logical expression can also be the special constants ''''@all''''
or ''''@none''''. The first always evaluates to true, the latter to false.

Date attributes needs special attention. Attributes like [[maxend]] can
be undefined. To use such an attribute in a comparison, you need to test for
the validity first. E. g. to compare the end date of the ''''plan''''
scenario with the ''''maxend'''' value use ''''isvalid(plan.maxend) &
(plan.end > plan.maxend)''''. The ''''&'''' and ''''|'''' operators are lazy.
If the result is already known after evaluation of the first operand, the second
operand will not be evaluated any more.
EOT
       )
    also(%w( functions ))
    example('LogicalExpression', '1')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2673
  def rule_macro
    pattern(%w( _macro $ID $MACRO ), lambda {
      if @scanner.macroDefined?(@val[1])
        warning('marco_redefinition', "Redefining macro #{@val[1]}")
      end
      @scanner.addMacro(TextParser::Macro.new(@val[1], @val[2],
                                              @sourceFileInfo[0]))
    })
    doc('macro', <<'EOT'
Defines a text fragment that can later be inserted by using the specified ID.
To insert the text fragment anywhere in the text you need to write ${ID}.The
body is not optional. It must be enclosed in square brackets. Macros can be
declared like this:

 macro FOO [ This text ]

If later ''''${FOO}'''' is found in the project file, it is expanded to
''''This text''''.

Macros may have arguments. Arguments are accessed with special macros with
numbers as names.  The number specifies the index of the argument.

 macro FOO [ This ${1} text ]

will expand to ''''This stupid text'''' if called as ''''${FOO "stupid"}''''.
Macros may call other macros. All macro arguments must be enclosed by double
quotes. In case the argument contains a double quote, it must be escaped by a
backslash (''''\'''').

User defined macro IDs should start with one uppercase letter as all
lowercase letter IDs are reserved for built-in macros.

To terminate the macro definition, the ''''<nowiki>]</nowiki>'''' must be the
last character in the line. If there are any other characters trailing it
(even spaces or comments) the ''''<nowiki>]</nowiki>'''' will not be
considered the end of the macro definition.

In macro calls the macro names can be prefixed by a question mark. In this
case the macro will expand to nothing if the macro is not defined. Otherwise
the undefined macro would be flagged with an error message.

The macro call

 ${?foo}

will expand to nothing if foo is undefined.
EOT
       )
    example('Macro-1')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2730
def rule_moreAlternatives
  commaListRule('!resourceId')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2734
def rule_moreArguments
  commaListRule('!argument')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2724
def rule_moreBangs
  optional
  repeatable
  singlePattern('_!')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2738
def rule_moreChargeSetItems
  commaListRule('!chargeSetItem')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2742
def rule_moreColumnDef
  commaListRule('!columnDef')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2746
def rule_moreDepTasks
  commaListRule('!taskDep')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2750
def rule_moreExportFormats
  commaListRule('!exportFormat')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2754
def rule_moreJournalSortCriteria
  commaListRule('!journalSortCriterium')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2758
def rule_moreListOfDays
  commaListRule('!weekDayInterval')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2762
def rule_moreOutputFormats
  commaListRule('!outputFormat')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2770
def rule_morePredTasks
  commaListRule('!taskPred')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2766
def rule_moreProjectIDs
  commaListRule('$ID')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2774
def rule_moreSortCriteria
  commaListRule('!sortNonTree')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2778
def rule_moreTimeIntervals
  commaListRule('!timeInterval')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2782
  def rule_navigator
    pattern(%w( !navigatorHeader !navigatorBody ), lambda {
      @project['navigators'][@navigator.id] = @navigator
    })
    doc('navigator', <<'EOT'
Defines a navigator object with the specified ID. This object can be used in
reports to include a navigation bar with references to other reports.
EOT
          )
    example('navigator')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2794
  def rule_navigatorAttributes
    optional
    repeatable
    pattern(%w( _hidereport !logicalExpression ), lambda {
      @navigator.hideReport = @val[1]
    })
    doc('hidereport', <<'EOT'
This attribute can be used to exclude the reports that match the specified
[[logicalexpression|logical expression]] from the navigation bar.
EOT
          )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2807
def rule_navigatorBody
  optional
  pattern(%w( _{ !navigatorAttributes _} ))
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2812
def rule_navigatorHeader
  pattern(%w( _navigator $ID ), lambda {
    if @project['navigators'][@val[1]]
      error('navigator_exists',
            "The navigator #{@val[1]} has already been defined.",
            @sourceFileInfo[0])
    end
    @navigator = Navigator.new(@val[1], @project)
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2872
  def rule_nikuReport
    pattern(%w( !nikuReportHeader !nikuReportBody ), lambda {
      @property = nil
    })
    doc('nikureport', <<'EOT'
This report generates an XML file to be imported into the enterprise resource
management software Clarity(R) from Computer Associates(R). The files contains
allocation curves for the specified resources. All tasks with identical user
defined attributes ''''ClarityPID'''' and ''''ClarityPNAME'''' are bundled
into a Clarity project. The resulting XML file can be imported into Clarity
with the xog-in tool.
EOT
       )
    example('Niku')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2823
  def rule_nikuReportAttributes
    optional
    repeatable

    pattern(%w( !formats ))
    pattern(%w( !headline ))
    pattern(%w( !hideresource ))
    pattern(%w( !hidetask ))

    pattern(%w( !numberFormat ), lambda {
      @property.set('numberFormat', @val[0])
    })

    pattern(%w( !reportEnd ))
    pattern(%w( !reportPeriod ))
    pattern(%w( !reportStart ))
    pattern(%w( !reportTitle ))

    pattern(%w( _timeoff $STRING $STRING ), lambda {
      @property.set('timeOffId', @val[1])
      @property.set('timeOffName', @val[2])
    })
    doc('timeoff.nikureport', <<EOF
Set the Clarity project ID and name that the vacation time will be reported to.
EOF
       )
    arg(1, 'ID', 'The Clarity project ID')
    arg(2, 'Name', 'The Clarity project name')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2853
def rule_nikuReportBody
  pattern(%w( _{ !nikuReportAttributes _} ), lambda {

  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2859
  def rule_nikuReportHeader
    pattern(%w( _nikureport !optionalID $STRING ), lambda {
      newReport(@val[1], @val[2], :niku, @sourceFileInfo[0]) do
        @property.set('numberFormat', RealFormat.new(['-', '', '', '.', 2]))
      end
    })
    arg(1, 'file name', <<'EOT'
The name of the time sheet report file to generate. It must end with a .tji
extension, or use . to use the standard output channel.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2888
def rule_nodeId
  pattern(%w( !idOrAbsoluteId !subNodeId ), lambda {
    case @property.typeSpec
    when :taskreport
      if (p1 = @project.task(@val[0])).nil?
        error('unknown_main_node',
              "Unknown task ID #{@val[0]}", @sourceFileInfo[0])
      end
      if @val[1]
        if (p2 = @project.resource(@val[1])).nil?
          error('unknown_sub_node',
                "Unknown resource ID #{@val[0]}", @sourceFileInfo[0])
        end
        return [ p2, p1 ]
      end
      return [ p1, nil ]
    when :resourcereport
      if (p1 = @project.task(@val[0])).nil?
        error('unknown_main_node',
              "Unknown task ID #{@val[0]}", @sourceFileInfo[0])
      end
      if @val[1]
        if (p2 = @project.resource(@val[1])).nil?
          error('unknown_sub_node',
                "Unknown resource ID #{@val[0]}", @sourceFileInfo[0])
        end
        return [ p2, p1 ]
      end
      return [ p1, nil ]
    end

    raise "Node list is not supported for this report type: " +
          "#{@property.typeSpec}"
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2924
def rule_nodeIdList
  listRule('moreNodeIdList', '!nodeId')
  pattern([ '_-' ], lambda {
    []
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 7653
def rule_nonZeroWorkingDuration
  pattern(%w( !workingDuration ), lambda {
    slots = @val[0]
    if slots <= 0
      error('working_duration_too_small',
            "Duration values must be at least " +
            "#{@project['scheduleGranularity'] / 60} minutes " +
            "(your timingresolution) long.")
    end
    slots
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2931
def rule_number
  singlePattern('$INTEGER')
  singlePattern('$FLOAT')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2936
def rule_numberFormat
  pattern(%w( _numberformat $STRING $STRING $STRING $STRING $INTEGER ),
      lambda {
    RealFormat.new(@val.slice(1, 5))
  })
  doc('numberformat',
      'These values specify the default format used for all numerical ' +
      'real values.')
  arg(1, 'negativeprefix', 'Prefix for negative numbers')
  arg(2, 'negativesuffix', 'Suffix for negative numbers')
  arg(3, 'thousandsep', 'Separator used for every 3rd digit')
  arg(4, 'fractionsep', 'Separator used to separate the fraction digits')
  arg(5, 'fractiondigits', 'Number of fraction digits to show')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 2951
def rule_operand
  pattern(%w( _( !operation _) ), lambda {
    @val[1]
  })
  pattern(%w( _~ !operand ), lambda {
    operation = LogicalOperation.new(@val[1])
    operation.operator = '~'
    operation
  })

  pattern(%w( $ABSOLUTE_ID ), lambda {
    if @val[0].count('.') > 1
      error('operand_attribute',
            'Attributes must be specified as <scenarioID>.<attribute>',
            @sourceFileInfo[0])
    end
    scenario, attribute = @val[0].split('.')
    if (scenarioIdx = @project.scenarioIdx(scenario)).nil?
      error('operand_unkn_scen', "Unknown scenario ID #{scenario}",
            @sourceFileInfo[0])
    end
    # TODO: Do at least some basic sanity checks of the attribute is valid.
    LogicalAttribute.new(attribute, @project.scenario(scenarioIdx))
  })
  pattern(%w( !date ), lambda {
    LogicalOperation.new(@val[0])
  })
  pattern(%w( $ID !argumentList ), lambda {
    if @val[1].nil?
      unless @project['flags'].include?(@val[0])
        error('operand_unkn_flag', "Undeclared flag '#{@val[0]}'",
              @sourceFileInfo[0])
      end
      LogicalFlag.new(@val[0])
    else
      func = LogicalFunction.new(@val[0])
      res = func.setArgumentsAndCheck(@val[1])
      unless res.nil?
        error(*res)
      end
      func
    end
  })
  pattern(%w( $INTEGER ), lambda {
    LogicalOperation.new(@val[0])
  })
  pattern(%w( $FLOAT ), lambda {
    LogicalOperation.new(@val[0])
  })
  pattern(%w( $STRING ), lambda {
    LogicalOperation.new(@val[0])
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3005
  def rule_operation
    pattern(%w( !operand !operationChain ), lambda {
      operation = LogicalOperation.new(@val[0])
      if @val[1]
        # Further operators/operands create an operation tree.
        @val[1].each do |ops|
          operation = LogicalOperation.new(operation)
          operation.operator = ops[0]
          operation.operand2 = ops[1]
        end
      end
      operation
    })
    arg(0, 'operand', <<'EOT'
An operand can consist of a date, a text string, a [[functions|function]], a
property attribute or a numerical value. It can also be the name of a declared
flag.  Use the ''''scenario_id.attribute'''' notation to use an attribute of
the currently evaluated property. The scenario ID always has to be specified,
also for non-scenario specific attributes. This is necessary to distinguish
them from flags. See [[columnid]] for a list of available attributes. The use
of list attributes is not recommended. User defined attributes are available
as well.

An operand can be a negated operand by prefixing a ~ character or it can be
another logical expression enclosed in braces.
EOT
        )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3034
def rule_operationChain
  optional
  repeatable
  pattern(%w( !operatorAndOperand), lambda {
    @val[0]
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3052
def rule_operator
  singlePattern('_|')
  descr('The \'or\' operator')

  singlePattern('_&')
  descr('The \'and\' operator')

  singlePattern('_>')
  descr('The \'greater than\' operator')

  singlePattern('_<')
  descr('The \'smaller than\' operator')

  singlePattern('_=')
  descr('The \'equal\' operator')

  singlePattern('_>=')
  descr('The \'greater-or-equal\' operator')

  singlePattern('_<=')
  descr('The \'smaller-or-equal\' operator')

  singlePattern('_!=')
  descr('The \'not-equal\' operator')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3042
  def rule_operatorAndOperand
    pattern(%w( !operator !operand), lambda{
      [ @val[0], @val[1] ]
    })
    arg(1, 'operand', <<'EOT'
An operand can consist of a date, a text string or a numerical value. It can also be the name of a declared flag. Finally, an operand can be a negated operand by prefixing a ~ character or it can be another operation enclosed in braces.
EOT
        )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3078
  def rule_optionalID
    optional
    pattern(%w( $ID ), lambda {
      @val[0]
    })
    arg(0, 'id', <<"EOT"
An optional ID. If you ever want to reference this property, you must specify
your own unique ID. If no ID is specified, one will be automatically generated.
These IDs may become visible in reports, but may change at any time. You may
never rely on automatically generated IDs.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3092
def rule_optionalMinus
  optional
  pattern(%w( _- ), lambda {
    true
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3099
def rule_optionalPercent
  optional
  pattern(%w( !number _% ), lambda {
    @val[0] / 100.0
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3105
def rule_optionalScenarioIdCol
  optional
  pattern(%w( $ID_WITH_COLON ), lambda {
    if (@scenarioIdx = @project.scenarioIdx(@val[0])).nil?
      error('unknown_scenario_id', "Unknown scenario: #{@val[0]}",
            @sourceFileInfo[0])
    end
    @scenarioIdx
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3117
  def rule_optionalVersion
    optional
    pattern(%w( $STRING ), lambda {
      @val[0]
    })
    arg(0, 'version', <<"EOT"
An optional version ID. This can be something simple as "4.2" or an ID tag of
a revision control system. If not specified, it defaults to "1.0".
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3129
  def rule_outputFormat
    pattern(%w( _csv ), lambda {
      :csv
    })
    descr(<<'EOT'
The report lists the resources and their respective values as
colon-separated-value (CSV) format. Due to the very simple nature of the CSV
format, only a small subset of features will be supported for CSV output.
Including tasks or listing multiple scenarios will result in very difficult to
read reports.
EOT
         )

    pattern(%w( _html ), lambda {
      :html
    })
    descr('Generate a web page (HTML file)')

    pattern(%w( _niku ), lambda {
      :niku
    })
    descr('Generate an XOG XML file to be used with Clarity.')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3153
def rule_outputFormats
  pattern(%w( !outputFormat !moreOutputFormats ), lambda {
    [ @val[0] ] + (@val[1].nil? ? [] : @val[1])
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3159
def rule_plusOrMinus
  singlePattern('_+')
  singlePattern('_-')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3164
def rule_project
  pattern(%w( !projectProlog !projectDeclaration !properties . ), lambda {
    @val[1]
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3170
def rule_projectBody
  optionsRule('projectBodyAttributes')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3174
  def rule_projectBodyAttributes
    repeatable
    optional

    pattern(%w( _alertlevels !alertLevelDefinitions ), lambda {
      if @val[1].length < 2
        error('too_few_alert_levels',
              'You must specify at least 2 different alert levels.',
              @sourceFileInfo[1])
      end
      levels = @project['alertLevels']
      levels.clear
      @val[1].each do |level|
        if levels.indexById(level[0])
          error('alert_level_redef',
                "Alert level '#{level[0]}' has been defined multiple times.",
                @sourceFileInfo[1])
        end

        if levels.indexByName(level[1])
          error('alert_name_redef',
                "Alert level name '#{level[1]}' has been defined multiple " +
                "times.", @sourceFileInfo[1])
        end

        @project['alertLevels'].add(AlertLevelDefinition.new(*level))
      end
    })
    level(:beta)
    doc('alertlevels', <<'EOT'
By default TaskJuggler supports the pre-defined alert levels: green, yellow
and red. This attribute can be used to replace them with your own set of alert
levels. You can define any number of levels, but you need to define at least
two and they must be specified in ascending order from the least severity to
highest severity. Additionally, you need to provide a 15x15 pixel image file
with the name ''''flag-X.png'''' for each level where ''''X'''' matches the ID
of the alert level. These files need to be in the ''''icons'''' directory to
be found by the browser when showing HTML reports.
EOT
       )
    example('AlertLevels')

    pattern(%w( !currencyFormat ), lambda {
      @project['currencyFormat'] = @val[0]
    })

    pattern(%w( _currency $STRING ), lambda {
      @project['currency'] = @val[1]
    })
    doc('currency', 'The default currency unit.')
    example('Account')
    arg(1, 'symbol', 'Currency symbol')

    pattern(%w( _dailyworkinghours !number ), lambda {
      @project['dailyworkinghours'] = @val[1]
    })
    doc('dailyworkinghours', <<'EOT'
Set the average number of working hours per day. This is used as
the base to convert working hours into working days. This affects
for example the length task attribute. The default value is 8 hours
and should work for most Western countries. The value you specify should match
the settings you specified as your default [[workinghours.project|working
hours]].
EOT
       )
    example('Project')
    arg(1, 'hours', 'Average number of working hours per working day')

    pattern(%w( _extend !extendProperty !extendBody ), lambda {
      updateParserTables
    })
    doc('extend', <<'EOT'
Often it is desirable to collect more information in the project file than is
necessary for task scheduling and resource allocation. To add such information
to tasks, resources or accounts, the user can extend these properties with
user-defined attributes. The new attributes can be of various types such as
text, date or reference to capture various types of data. Optionally the user
can specify if the attribute value should be inherited from the enclosing
property.
EOT
       )
    example('CustomAttributes')

    pattern(%w( !projectBodyInclude ))

    pattern(%w( !journalEntry ))

    pattern(%w( _now !date ), lambda {
      @project['now'] = @val[1]
      @scanner.addMacro(TextParser::Macro.new('now', @val[1].to_s,
                                              @sourceFileInfo[0]))
      @scanner.addMacro(TextParser::Macro.new(
        'today', @val[1].to_s(@project['timeFormat']), @sourceFileInfo[0]))
    })
    doc('now', <<'EOT'
Specify the date that TaskJuggler uses for calculation as current
date. If no value is specified, the current value of the system
clock is used.
EOT
       )
    arg(1, 'date', 'Alternative date to be used as current date for all ' +
        'computations')

    pattern(%w( _markdate !date ), lambda {
      @project['markdate'] = @val[1]
      @scanner.addMacro(TextParser::Macro.new('markdate', @val[1].to_s,
                                              @sourceFileInfo[0]))
      @scanner.addMacro(TextParser::Macro.new(
        'today', @val[1].to_s(@project['timeFormat']), @sourceFileInfo[0]))
    })
    doc('markdate', <<'EOT'
Specify the reference date that TaskJuggler uses as date that can be specified
and set by the user. It can be used as additional point in time to help with
tracking tasks. If no value is specified, the current value of the system clock is used.
EOT
       )
    arg(1, 'date', 'Alternative date to be used as custom date specified by the user')

    pattern(%w( !numberFormat ), lambda {
      @project['numberFormat'] = @val[0]
    })

    pattern(%w( _outputdir $STRING ), lambda {
      # Directory name must be terminated by a slash.
      if @val[1].empty?
        error('outdir_empty', 'Output directory may not be empty.')
      end
      if !File.directory?(@val[1])
        error('outdir_missing',
              "Output directory '#{@val[1]}' does not exist or is not " +
              "a directory!")
      end
      @project.outputDir = @val[1] + (@val[1][-1] == ?/ ? '' : '/')
    })
    doc('outputdir',
        'Specifies the directory into which the reports should be generated. ' +
        'This will not affect reports whose name start with a slash. This ' +
        'setting can be overwritten by the command line option -o or --output-dir.')
    arg(1, 'directory', 'Path to an existing directory')

    pattern(%w( !scenario ))
    pattern(%w( _shorttimeformat $STRING ), lambda {
      @project['shortTimeFormat'] = @val[1]
    })
    doc('shorttimeformat',
        'Specifies time format for short time specifications. This is normal ' +
        'just hours and minutes.')
    arg(1, 'format', 'strftime like format string')

    pattern(%w( !timeformat ), lambda {
      @project['timeFormat'] = @val[0]
    })

    pattern(%w( !timezone ), lambda {
      @val[0]
    })

    pattern(%w( _timingresolution $INTEGER _min ), lambda {
      goodValues = [ 5, 10, 15, 20, 30, 60 ]
      unless goodValues.include?(@val[1])
        error('bad_timing_res',
              "Timing resolution must be one of #{goodValues.join(', ')} min.",
              @sourceFileInfo[1])
      end
      if @val[1] > (Project.maxScheduleGranularity / 60)
        error('too_large_timing_res',
              'The maximum allowed timing resolution for the timezone is ' +
              "#{Project.maxScheduleGranularity / 60} minutes.",
              @sourceFileInfo[1])
      end
      @project['scheduleGranularity'] = @val[1] * 60
    })
    doc('timingresolution', <<'EOT'
Sets the minimum timing resolution. The smaller the value, the longer the
scheduling process lasts and the more memory the application needs. The
default and maximum value is 1 hour. The smallest value is 5 min.
This value is a pretty fundamental setting of TaskJuggler. It has a severe
impact on memory usage and scheduling performance. You should set this value
to the minimum required resolution. Make sure that all values that you specify
are aligned with the resolution.

Changing the timing resolution will reset the [[workinghours.project|working
hours]] to the default times. It's recommended that this is the very first
option in the project header section.

Do not use this option after you've set the time zone!
EOT
        )

    pattern(%w( _trackingscenario !scenarioId ), lambda {
      @project['trackingScenarioIdx'] = @val[1]
      # The tracking scenario and all child scenarios will always be scheduled
      # in projection mode.
      @project.scenario(@val[1]).all.each do |scenario|
        scenario.set('projection', true)
      end
    })
    doc('trackingscenario', <<'EOT'
Specifies which scenario is used to capture what actually has happened with
the project. All sub-scenarios of this scenario inherit the bookings of the
tracking scenario and may not have any bookings of their own. The tracking
scenario must also be specified to use time and status sheet reports.

The tracking scenario must be defined after all scenarios have been defined.

The tracking scenario and all scenarios derived from it will be scheduled in
projection mode. This means that the scheduler will only add bookings after
the current date or the date specified by [[now]]. It is assumed that all
allocations prior to this date have been provided as [[booking.task|
task bookings]] or [[booking.resource|resource bookings]].
EOT
       )
    example('TimeSheet1', '2')

    pattern(%w( _weekstartsmonday ), lambda {
      @project['weekStartsMonday'] = true
    })
    doc('weekstartsmonday',
        'Specify that you want to base all week calculation on weeks ' +
        'starting on Monday. This is common in many European countries.')

    pattern(%w( _weekstartssunday ), lambda {
      @project['weekStartsMonday'] = false
    })
    doc('weekstartssunday',
        'Specify that you want to base all week calculation on weeks ' +
        'starting on Sunday. This is common in the United States of America.')

    pattern(%w( !workinghoursProject ))
    pattern(%w( _yearlyworkingdays !number ), lambda {
      @project['yearlyworkingdays'] = @val[1]
    })
    doc('yearlyworkingdays', <<'EOT'
Specifies the number of average working days per year. This should correlate
to the specified workinghours and vacation. It affects the conversion of
working hours, working days, working weeks, working months and working years
into each other.

When public holidays and leaves are disregarded, this value should be equal
to the number of working days per week times 52.1428 (the average number of
weeks per year). E. g. for a culture with 5 working days it is 260.714 (the
default), for 6 working days it is 312.8568 and for 7 working days it is
365.
EOT
       )
    arg(1, 'days', 'Number of average working days for a year')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3508
  def rule_projectBodyInclude
    pattern(%w( _include !includeFile !projectBodyAttributes . ))
    lastSyntaxToken(1)
    doc('include.project', <<'EOT'
Includes the specified file name as if its contents would be written
instead of the include property. When the included files contains other
include statements or report definitions, the filenames are relative to the file
where they are defined in.

This version of the include directive may only be used inside the [[project]]
header section. The included files must only contain content that may be
present in a project header section.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3422
  def rule_projectDeclaration
    pattern(%w( !projectHeader !projectBody ), lambda {
      # If the user has specified a tracking scenario, we mark all children of
      # that scenario to disallow own bookings. These scenarios will inherit
      # their bookings from the tracking scenario.
      if (idx = @project['trackingScenarioIdx'])
        @project.scenario(idx).allLeaves(true).each do |scenario|
          scenario.set('ownbookings', false)
        end
      end
      @val[0]
    })
    doc('project', <<'EOT'
The project property is mandatory and should be the first property
in a project file. It is used to capture basic attributes such as
the project id, name and the expected time frame.

Be aware that the dates for the project period default to UTC times. See [[interval2]] for details.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3444
def rule_projectHeader
  pattern(%w( _project !optionalID $STRING !optionalVersion !interval ), lambda {
    @project = Project.new(@val[1], @val[2], @val[3])
    @project['start'] = @val[4].start
    @project['end'] = @val[4].end
    @projectId = @val[1]
    setGlobalMacros
    @property = nil
    @reportCounter = 0
    @project
  })
  arg(2, 'name', 'The name of the project')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3458
def rule_projectIDs
  pattern(%w( $ID !moreProjectIDs ), lambda {
    [ @val[0] ] + (@val[1].nil? ? [] : @val[1])
  })
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3485
def rule_projectProlog
  optional
  repeatable
  pattern(%w( !prologInclude ))
  pattern(%w( !macro ))
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3492
  def rule_projectProperties
    # This rule is not defining actual syntax. It's only used for the
    # documentation.
    pattern(%w( !projectPropertiesBody ))
    doc('properties', <<'EOT'
The project properties. Every project must consist of at least one task. The other properties are optional. To save the scheduled data at least one output generating property should be used.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3502
def rule_projectPropertiesBody
  # This rule is not defining actual syntax. It's only used for the
  # documentation.
  optionsRule('properties')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3464
def rule_projection
  optionsRule('projectionAttributes')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3468
def rule_projectionAttributes
  optional
  repeatable
  pattern(%w( _sloppy ))
  level(:deprecated)
  also('trackingscenario')
  doc('sloppy.projection', '')

  pattern(%w( _strict ), lambda {
    warning('projection_strict',
            'The strict mode is now always used.')
  })
  level(:deprecated)
  also('trackingscenario')
  doc('strict.projection', '')
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3524
  def rule_prologInclude
    pattern(%w( _include !includeFile !projectProlog . ))
    lastSyntaxToken(1)
    doc('include.macro', <<'EOT'
Includes the specified file name as if its contents would be written
instead of the include property. The only exception is the include
statement itself. When the included files contains other include
statements or report definitions, the filenames are relative to the file
where they are defined in.

The included file may only contain macro definitions. This version of the
include directive can only be used before the [[project]] header.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3540
def rule_properties
  pattern(%w( !propertiesBody ))
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3544
  def rule_propertiesBody
    repeatable
    optional

    pattern(%w( !account ))

    pattern(%w( _auxdir $STRING ), lambda {
      auxdir = @val[1]
      # Ensure that the directory always ends with a '/'.
      auxdir += '/' unless auxdir[-1] == ?/
      @project['auxdir'] = auxdir
    })
    level(:beta)
    doc('auxdir', <<'EOT'
Specifies an alternative directory for the auxiliary report files such as CSS,
JavaScript and icon files. This setting will affect all subsequent report
definitions unless it gets overridden. If this attribute is not set, the
directory and its contents will be generated automatically. If this attribute
is provided, the user has to ensure that the directory exists and is filled
with the proper data. The specified path can be absolute or relative to the
generated report file.
EOT
       )

    pattern(%w( _copyright $STRING ), lambda {
      @project['copyright'] = @val[1]
    })
    doc('copyright', <<'EOT'
Set a copyright notice for the project file and its content. This copyright notice will be added to all reports that can support it.
EOT
       )
    example('Caption', '2')

    pattern(%w( !balance ), lambda {
      @project['costaccount'] = @val[0][0]
      @project['revenueaccount'] = @val[0][1]
    })

    pattern(%w( _flags !declareFlagList ), lambda {
      unless @project['flags'].include?(@val[1])
        @project['flags'] += @val[1]
      end
    })
    doc('flags', <<'EOT'
Declare one or more flag for later use. Flags can be used to mark tasks, resources or other properties to filter them in reports.
EOT
       )

    pattern(%w( !propertiesInclude ))

    pattern(%w( !leaves ), lambda {
      @val[0].each do |v|
        @project['leaves'] << v
      end
    })

    pattern(%w( !limits ), lambda {
      @project['limits'] = @val[0]
    })
    doc('limits', <<'EOT'
Set per-interval allocation limits for the following resource definitions.
The limits can be overwritten in each resource definition and the global
limits can be changed later.
EOT
       )

    pattern(%w( !macro ))

    pattern(%w( !navigator ))

    pattern(%w( _projectid $ID ), lambda {
      @project['projectids'] << @val[1]
      @project['projectids'].uniq!
      @project['projectid'] = @projectId = @val[1]
    })
    doc('projectid', <<'EOT'
This declares a new project id and activates it. All subsequent
task definitions will inherit this ID. The tasks of a project can have
different IDs.  This is particularly helpful if the project is merged from
several sub projects that each have their own ID.
EOT
       )

    pattern(%w( _projectids !projectIDs ), lambda {
      @project['projectids'] += @val[1]
      @project['projectids'].uniq!
    })
    doc('projectids', <<'EOT'
Declares a list of project IDs. When an include file that was generated from another project brings different project IDs, these need to be declared first.
EOT
        )

    pattern(%w( _rate !number ), lambda {
      @project['rate'] = @val[1].to_f
    })
    doc('rate', <<'EOT'
Set the default rate for all subsequently defined resources. The rate describes the daily cost of a resource.
EOT
        )

    pattern(%w( !reportProperties ))
    pattern(%w( !resource ))
    pattern(%w( !shift ))
    pattern(%w( !statusSheet ))

    pattern(%w( _supplement !supplement ))
    doc('supplement', <<'EOT'
The supplement keyword provides a mechanism to add more attributes to already
defined accounts, tasks or resources. The additional attributes must obey the
same rules as in regular task or resource definitions and must be enclosed by
curly braces.

This construct is primarily meant for situations where the information about a
task or resource is split over several files. E. g. the vacation dates for the
resources may be in a separate file that was generated by some other tool.
EOT
       )
    example('Supplement')

    pattern(%w( !task ))
    pattern(%w( !timeSheet ))
    pattern(%w( _vacation !vacationName !intervals ), lambda {
      @val[2].each do |interval|
        @project['leaves'] << Leave.new(:holiday, interval)
      end
    })
    doc('vacation', <<'EOT'
Specify a global vacation period for all subsequently defined resources. A
vacation can also be used to block out the time before a resource joined or
after it left. For employees changing their work schedule from full-time to
part-time, or vice versa, please refer to the 'Shift' property.
EOT
       )
    arg(1, 'name', 'Name or purpose of the vacation')
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3680
def rule_propertiesFile
  pattern(%w( !propertiesBody . ))
end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3684
  def rule_propertiesInclude
    pattern(%w( _include !includeProperties !properties . ), lambda {
    })
    lastSyntaxToken(1)
    doc('include.properties', <<'EOT'
Includes the specified file name as if its contents would be written
instead of the include property. The only exception is the include
statement itself. When the included files contains other include
statements or report definitions, the filenames are relative to the file
where they are defined in. include commands can be used in the project
header, at global scope or between property declarations of tasks,
resources, and accounts.

For technical reasons you have to supply the optional pair of curly
brackets if the include is followed immediately by a macro call that
is defined within the included file.
EOT
       )
  end

# File lib/taskjuggler/TjpSyntaxRules.rb, line 3704
  def rule_purge
    pattern(%w( _purge !optionalScenarioIdCol $ID ), lambda {
      attrId = @val[2]
      if (attributeDefinition = @property.attributeDefinition(attrId)).nil?
        error('purge_unknown_id',
              "#{attrId} is not a known attribute for this property",
              @sourceFileInfo[2])
      end
      if attributeDefinition.scenarioSpecific
        @scenarioIdx = 0 unless @val[1]
      else
        if @val[1]
          error('purge_non_sc_spec_attr',
                'Scenario specified for a non-scenario specific attribute')
        end
      end
      if @property.attributeDefinition(attrId).scenarioSpecific
        @property.getAttribute(attrId, @scenarioIdx).reset
      else
        @property.getAttribute(attrId).reset
      end
    })
    doc('purge', <<'EOT'
Many attributes inherit their values from the enclosing property or the global
scope. In certain circumstances, this is not desirable, e. g. for list
attributes. A list attribute is any attribute that takes a comma separated
list of values as argument. [[allocate]] and [[flags.task]] are
good examples of commonly used list attributes. By defining values for
such a list attribute in a nested property, the new values will be appended to
the list that was inherited from the enclosing property. The purge
attribute resets any attribute to its default value. A subsequent definition
for the attribute within the property will then add their values to an empty
list. The value of the enclosing property is not affected by purge.

For scenario specific attributes, an optional scenario ID can be specified
before the attribute ID. If it's missing, the default (first) scenario will be
used.
EOT
       )
    arg(1, 'attribute', 'Any name of a list attribute')
  end