### Home Classes Methods

### In Files

- lib/taskjuggler/SyntaxReference.rb

### Parent

Object

### Methods

- ::new
- #all
- #generateHTMLnavbar
- #generateHTMLreference
- #internalReferences
- #tableOfContents
- #to_s

### Files

- CHANGELOG
- COPYING
- README.rdoc

### Class/Module Index

Quicksearch

- TaskJuggler
- TaskJuggler::Account
- TaskJuggler::AccountAttribute
- TaskJuggler::AccountCredit
- TaskJuggler::AccountCreditListAttribute
- TaskJuggler::AccountListRE
- TaskJuggler::AccountScenario
- TaskJuggler::AlertLevelDefinition
- TaskJuggler::AlertLevelDefinitions
- TaskJuggler::Allocation
- TaskJuggler::AllocationAttribute
- TaskJuggler::AttributeBase
- TaskJuggler::AttributeDefinition
- TaskJuggler::AttributeOverwrite
- TaskJuggler::BatchProcessor
- TaskJuggler::Booking
- TaskJuggler::BookingListAttribute
- TaskJuggler::BooleanAttribute
- TaskJuggler::CSVFile
- TaskJuggler::CellSettingPattern
- TaskJuggler::CellSettingPatternList
- TaskJuggler::Charge
- TaskJuggler::ChargeListAttribute
- TaskJuggler::ChargeSet
- TaskJuggler::ChargeSetListAttribute
- TaskJuggler::ChartPlotter
- TaskJuggler::ChartPlotterError
- TaskJuggler::CollisionDetector
- TaskJuggler::ColumnListAttribute
- TaskJuggler::ColumnTable
- TaskJuggler::Daemon
- TaskJuggler::DaemonConnector
- TaskJuggler::DaemonConnectorMixin
- TaskJuggler::DataCache
- TaskJuggler::DataCacheEntry
- TaskJuggler::DateAttribute
- TaskJuggler::DefinitionListAttribute
- TaskJuggler::DependencyListAttribute
- TaskJuggler::DurationAttribute
- TaskJuggler::ExportRE
- TaskJuggler::FileList
- TaskJuggler::FileRecord
- TaskJuggler::FixnumAttribute
- TaskJuggler::FlagListAttribute
- TaskJuggler::FloatAttribute
- TaskJuggler::FormatListAttribute
- TaskJuggler::GanttChart
- TaskJuggler::GanttContainer
- TaskJuggler::GanttHeader
- TaskJuggler::GanttHeaderScaleItem
- TaskJuggler::GanttLine
- TaskJuggler::GanttLoadStack
- TaskJuggler::GanttMilestone
- TaskJuggler::GanttRouter
- TaskJuggler::GanttTaskBar
- TaskJuggler::HTMLDocument
- TaskJuggler::HTMLElements
- TaskJuggler::HTMLGraphics
- TaskJuggler::ICalReport
- TaskJuggler::ICalendar
- TaskJuggler::ICalendar::Component
- TaskJuggler::ICalendar::Event
- TaskJuggler::ICalendar::Journal
- TaskJuggler::ICalendar::Person
- TaskJuggler::ICalendar::Todo
- TaskJuggler::Interval
- TaskJuggler::IntervalList
- TaskJuggler::JobInfo
- TaskJuggler::Journal
- TaskJuggler::JournalEntry
- TaskJuggler::JournalEntryList
- TaskJuggler::JournalSortListAttribute
- TaskJuggler::KateSyntax
- TaskJuggler::KeywordArray
- TaskJuggler::KeywordDocumentation
- TaskJuggler::Leave
- TaskJuggler::LeaveAllowance
- TaskJuggler::LeaveAllowanceList
- TaskJuggler::LeaveAllowanceListAttribute
- TaskJuggler::LeaveList
- TaskJuggler::LeaveListAttribute
- TaskJuggler::Limits
- TaskJuggler::Limits::Limit
- TaskJuggler::LimitsAttribute
- TaskJuggler::ListAttributeBase
- TaskJuggler::Log
- TaskJuggler::LogicalAttribute
- TaskJuggler::LogicalExpression
- TaskJuggler::LogicalExpressionAttribute
- TaskJuggler::LogicalExpressionListAttribute
- TaskJuggler::LogicalFlag
- TaskJuggler::LogicalFunction
- TaskJuggler::LogicalOperation
- TaskJuggler::ManagerResponsibilities
- TaskJuggler::ManagerStatusRecord
- TaskJuggler::Message
- TaskJuggler::MessageHandler
- TaskJuggler::MessageHandlerInstance
- TaskJuggler::MspXmlRE
- TaskJuggler::Navigator
- TaskJuggler::NavigatorElement
- TaskJuggler::NikuProject
- TaskJuggler::NikuReport
- TaskJuggler::NikuResource
- TaskJuggler::NodeListAttribute
- TaskJuggler::PTNProxy
- TaskJuggler::Painter
- TaskJuggler::Painter::Circle
- TaskJuggler::Painter::Color
- TaskJuggler::Painter::Element
- TaskJuggler::Painter::Ellipse
- TaskJuggler::Painter::FontMetrics
- TaskJuggler::Painter::FontMetricsData
- TaskJuggler::Painter::Group
- TaskJuggler::Painter::Line
- TaskJuggler::Painter::Points
- TaskJuggler::Painter::PolyLine
- TaskJuggler::Painter::Primitives
- TaskJuggler::Painter::Rect
- TaskJuggler::Painter::SVGSupport
- TaskJuggler::Painter::Text
- TaskJuggler::PlaceHolderCell
- TaskJuggler::ProcessIntercom
- TaskJuggler::ProcessIntercomIface
- TaskJuggler::Project
- TaskJuggler::ProjectBroker
- TaskJuggler::ProjectBrokerIface
- TaskJuggler::ProjectFileParser
- TaskJuggler::ProjectFileScanner
- TaskJuggler::ProjectRecord
- TaskJuggler::ProjectServer
- TaskJuggler::ProjectServerIface
- TaskJuggler::PropertyAttribute
- TaskJuggler::PropertyList
- TaskJuggler::PropertySet
- TaskJuggler::PropertyTreeNode
- TaskJuggler::Query
- TaskJuggler::RTFHandlers
- TaskJuggler::RTFNavigator
- TaskJuggler::RTFQuery
- TaskJuggler::RTFReport
- TaskJuggler::RTFReportLink
- TaskJuggler::RTFWithQuerySupport
- TaskJuggler::RealFormat
- TaskJuggler::RealFormatAttribute
- TaskJuggler::ReferenceAttribute
- TaskJuggler::Report
- TaskJuggler::ReportBase
- TaskJuggler::ReportContext
- TaskJuggler::ReportScenario
- TaskJuggler::ReportServer
- TaskJuggler::ReportServerIface
- TaskJuggler::ReportServerRecord
- TaskJuggler::ReportServlet
- TaskJuggler::ReportTable
- TaskJuggler::ReportTableCell
- TaskJuggler::ReportTableColumn
- TaskJuggler::ReportTableLegend
- TaskJuggler::ReportTableLine
- TaskJuggler::Resource
- TaskJuggler::ResourceListAttribute
- TaskJuggler::ResourceListRE
- TaskJuggler::ResourceScenario
- TaskJuggler::RichText
- TaskJuggler::RichTextAttribute
- TaskJuggler::RichTextDocument
- TaskJuggler::RichTextElement
- TaskJuggler::RichTextFunctionExample
- TaskJuggler::RichTextFunctionHandler
- TaskJuggler::RichTextImage
- TaskJuggler::RichTextIntermediate
- TaskJuggler::RichTextParser
- TaskJuggler::RichTextScanner
- TaskJuggler::RichTextSnip
- TaskJuggler::RichTextSyntaxRules
- TaskJuggler::Scenario
- TaskJuggler::ScenarioData
- TaskJuggler::ScenarioListAttribute
- TaskJuggler::Scoreboard
- TaskJuggler::ScoreboardInterval
- TaskJuggler::SheetHandlerBase
- TaskJuggler::SheetReceiver
- TaskJuggler::SheetSender
- TaskJuggler::Shift
- TaskJuggler::ShiftAssignment
- TaskJuggler::ShiftAssignments
- TaskJuggler::ShiftAssignmentsAttribute
- TaskJuggler::ShiftScenario
- TaskJuggler::SimpleQueryExpander
- TaskJuggler::SortListAttribute
- TaskJuggler::StatusSheetReceiver
- TaskJuggler::StatusSheetReport
- TaskJuggler::StatusSheetSender
- TaskJuggler::StdIoWrapper
- TaskJuggler::StringAttribute
- TaskJuggler::SymbolAttribute
- TaskJuggler::SymbolListAttribute
- TaskJuggler::SyntaxReference
- TaskJuggler::TOCEntry
- TaskJuggler::TSResourceRecord
- TaskJuggler::TSTaskRecord
- TaskJuggler::TableColumnDefinition
- TaskJuggler::TableColumnSorter
- TaskJuggler::TableOfContents
- TaskJuggler::TableReport
- TaskJuggler::TableReportColumn
- TaskJuggler::TagFile
- TaskJuggler::TagFile::TagFileEntry
- TaskJuggler::Task
- TaskJuggler::TaskDepListAttribute
- TaskJuggler::TaskDependency
- TaskJuggler::TaskListAttribute
- TaskJuggler::TaskListRE
- TaskJuggler::TaskScenario
- TaskJuggler::TernarySearchTree
- TaskJuggler::TextFormatter
- TaskJuggler::TextParser
- TaskJuggler::TextParser::Macro
- TaskJuggler::TextParser::MacroTable
- TaskJuggler::TextParser::Pattern
- TaskJuggler::TextParser::Rule
- TaskJuggler::TextParser::Scanner
- TaskJuggler::TextParser::Scanner::BufferStreamHandle
- TaskJuggler::TextParser::Scanner::FileStreamHandle
- TaskJuggler::TextParser::Scanner::MacroStackEntry
- TaskJuggler::TextParser::Scanner::StreamHandle
- TaskJuggler::TextParser::SourceFileInfo
- TaskJuggler::TextParser::StackElement
- TaskJuggler::TextParser::State
- TaskJuggler::TextParser::StateTransition
- TaskJuggler::TextParser::TextParserResultArray
- TaskJuggler::TextParser::TokenDoc
- TaskJuggler::TextReport
- TaskJuggler::TimeInterval
- TaskJuggler::TimeIntervalListAttribute
- TaskJuggler::TimeSheet
- TaskJuggler::TimeSheetReceiver
- TaskJuggler::TimeSheetRecord
- TaskJuggler::TimeSheetReport
- TaskJuggler::TimeSheetSender
- TaskJuggler::TimeSheetSummary
- TaskJuggler::TimeSheets
- TaskJuggler::Tj3
- TaskJuggler::Tj3AppBase
- TaskJuggler::Tj3Client
- TaskJuggler::Tj3Daemon
- TaskJuggler::Tj3Man
- TaskJuggler::Tj3SheetAppBase
- TaskJuggler::Tj3SsReceiver
- TaskJuggler::Tj3SsSender
- TaskJuggler::Tj3TsReceiver
- TaskJuggler::Tj3TsSender
- TaskJuggler::Tj3TsSummary
- TaskJuggler::Tj3WebD
- TaskJuggler::TjException
- TaskJuggler::TjRuntimeError
- TaskJuggler::TjTime
- TaskJuggler::TjpExample
- TaskJuggler::TjpExportRE
- TaskJuggler::TjpSyntaxRules
- TaskJuggler::TraceReport
- TaskJuggler::URLParameter
- TaskJuggler::UserManual
- TaskJuggler::VimSyntax
- TaskJuggler::WebServer
- TaskJuggler::WelcomePage
- TaskJuggler::WorkingHours
- TaskJuggler::WorkingHoursAttribute
- TaskJuggler::XMLBlob
- TaskJuggler::XMLComment
- TaskJuggler::XMLDocument
- TaskJuggler::XMLElement
- TaskJuggler::XMLNamedText
- TaskJuggler::XMLText
- Diff
- Diff::Hunk
- AppConfig
- Diffable
- DiffableString
- Object
- RuntimeConfig
- String

No matching classes.

# TaskJuggler::SyntaxReference

This class can traverse the syntax rules of the ProjectFileParser and extract all documented keywords including their arguments and relations. All this work in done in the contructor. The documentation can then be generated for all found keyword or just a single one. Currently plain text output as well as HTML files are supported.

### Attributes

keywords[R]

### Public Class Methods

new(manual = nil, ignoreOld = false) click to toggle source

The constructor is the most important function of this class. It creates a parser object and then traverses all rules and extracts the documented patterns. In a second pass the extracted KeywordDocumentation objects are then cross referenced to capture their relationships. manual is an optional reference to the UserManual object that uses this SyntaxReference.

    # File lib/taskjuggler/SyntaxReference.rb, line 34
    def initialize(manual = nil, ignoreOld = false)
      @manual = manual
      @parser = ProjectFileParser.new
      @parser.updateParserTables

      # This hash stores all documented keywords using the keyword as
      # index.
      @keywords = {}
      @parser.rules.each_value do |rule|
        rule.patterns.each do |pattern|
          #  Only patterns that are documented are of interest.
          next if pattern.doc.nil?
          # Ignore deprecated and removed keywords if requested
          next if ignoreOld &&
                  [ :deprecated, :removed ].include?(pattern.supportLevel)

          # Make sure each keyword is unique.
          if @keywords.include?(pattern.keyword)
            raise "Multiple patterns have the same keyword #{pattern.keyword}"
          end

          argDocs = []
          # Create a new KeywordDocumentation object and fill-in all extracted
          # values.
          kwd = KeywordDocumentation.new(rule, pattern,
                  pattern.to_syntax(argDocs, @parser.rules), argDocs,
                  optionalAttributes(pattern, {}), @manual)
          @keywords[pattern.keyword] = kwd
        end
      end

      # Make sure all references to other keywords are present.
      @keywords.each_value do |kwd|
        kwd.crossReference(@keywords, @parser.rules)
      end

      # Figure out whether the keyword describes an inheritable attribute or
      # not.
      @keywords.each_value do |kwd|
        kwd.computeInheritance(@keywords, @parser.rules)
      end
    end

### Public Instance Methods

all() click to toggle source

Return a sorted Array with all keywords (as String objects).

    # File lib/taskjuggler/SyntaxReference.rb, line 78
    def all
      sorted = @keywords.keys.sort
      # Register the neighbours with each keyword so we can use this info in
      # navigation bars.
      pred = nil
      sorted.each do |kwd|
        keyword = @keywords[kwd]
        pred.successor = keyword if pred
        keyword.predecessor = pred
        pred = keyword
      end
    end

generateHTMLnavbar(directory, keywords) click to toggle source

Generate 2 files named navbar.html and alphabet.html. They are used to support navigating through the syntax reference.

    # File lib/taskjuggler/SyntaxReference.rb, line 142
    def generateHTMLnavbar(directory, keywords)
      html = HTMLDocument.new
      head = html.generateHead('TaskJuggler Syntax Reference Navigator')
      head << XMLElement.new('base', 'target' => 'display')
      html.html << (body = XMLElement.new('body'))

      body << XMLNamedText.new('Table Of Contents', 'a', 'href' => 'toc.html')
      body << XMLElement.new('br', {}, true)

      normalizedKeywords = {}
      keywords.each do |keyword|
        normalizedKeywords[@keywords[keyword].title] = keyword
      end
      letter = nil
      letters = []
      normalizedKeywords.keys.sort!.each do |normalized|
        if normalized[0, 1] != letter
          letter = normalized[0, 1]
          letters << letter
          body << (h = XMLElement.new('h3'))
          h << XMLNamedText.new(letter.upcase, 'a', 'name' => letter)
        end
        keyword = normalizedKeywords[normalized]
        body << XMLNamedText.new("#{normalized}", 'a',
                                 'href' => "#{keyword}.html")
        body << XMLElement.new('br', {}, true)
      end

      html.write(directory + 'navbar.html')

      html = HTMLDocument.new
      head = html.generateHead('TaskJuggler Syntax Reference Navigator')
      head << XMLElement.new('base', 'target' => 'navigator')
      html.html << (body = XMLElement.new('body'))

      body << (h3 = XMLElement.new('h3'))
      letters.each do |l|
        h3 << XMLNamedText.new(l.upcase, 'a',
                               'href' => "navbar.html##{l}")
      end
      html.write(directory + 'alphabet.html')
    end

generateHTMLreference(directory, keyword) click to toggle source

Generate a documentation for the keyword or an error message. The result is a XML String for known keywords. In case of an error the result is empty but an error message will be send to $stderr.

    # File lib/taskjuggler/SyntaxReference.rb, line 132
    def generateHTMLreference(directory, keyword)
      if checkKeyword(keyword)
        @keywords[keyword].generateHTML(directory)
      else
        ''
      end
    end

internalReferences() click to toggle source

    # File lib/taskjuggler/SyntaxReference.rb, line 109
    def internalReferences
      references = {}
      @keywords.each_value do |keyword|
        (refs = keyword.references.uniq).empty? ||
          references[keyword.keyword] = refs
      end
      references
    end

tableOfContents(toc, sectionPrefix) click to toggle source

Generate entries for a TableOfContents for each of the keywords. The entries are appended to the TableOfContents toc. sectionPrefix is the prefix that is used for the chapter numbers. In case we have 20 keywords and sectionPrefix is 'A', the keywords will be enumerated 'A.1' to 'A.20'.

    # File lib/taskjuggler/SyntaxReference.rb, line 96
    def tableOfContents(toc, sectionPrefix)
      keywords = all
      # Set the chapter name to 'Syntax Reference' with a link to the first
      # keyword.
      toc.addEntry(TOCEntry.new(sectionPrefix, 'Syntax Reference', keywords[0]))
      i = 1
      keywords.each do |keyword|
        title = @keywords[keyword].title
        toc.addEntry(TOCEntry.new("#{sectionPrefix}.#{i}", title, keyword))
        i += 1
      end
    end

to_s(keyword) click to toggle source

Generate a documentation for the keyword or an error message. The result is a multi-line plain text String for known keywords. In case of an error the result is empty but an error message will be send to $stderr.

    # File lib/taskjuggler/SyntaxReference.rb, line 121
    def to_s(keyword)
      if checkKeyword(keyword)
        @keywords[keyword].to_s
      else
        ''
      end
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.