Class: JsDuck::TypeParser

Inherits:
Object
  • Object
show all
Defined in:
lib/jsduck/type_parser.rb

Overview

Validates the syntax of type definitions.

The parser supports a combination of two syntaxes:

  1. Traditional type expressions found in ExtJS code:

    "string"
3.14
SomeType
Name.spaced.Type
Number[]
String/RegExp
Type...

  2. Google Closure Compiler Type Expressions:

    boolean
Window
goog.ui.Menu

Array.<string>
Object.<string, number>

{myNum: number, myObject}

(number|boolean)
?number
!Object
...number
*

function(string, boolean): number
function(new:goog.ui.Menu, string)
function(this:goog.ui.Menu, string)
function(?string=, number=)
function(string, ...[number])

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(formatter) ⇒ TypeParser

Initializes the parser with a Format::Doc instance.



54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/jsduck/type_parser.rb', line 54

def initialize(formatter)
  @relations = formatter.relations
  @formatter = formatter
  @primitives = {
    "boolean" => "Boolean",
    "number" => "Number",
    "string" => "String",
    "null" => "null",
    "undefined" => "undefined",
    "void" => "void",
  }
end

Instance Attribute Details

#error ⇒ Object (readonly)

Allows to check the type of error that was encountered. It will be either of the two:

  • :syntax - type definition syntax is incorrect

  • :name - one of the names of the types is unknown



47
48
49
 
# File 'lib/jsduck/type_parser.rb', line 47

def error
  @error
end

#out ⇒ Object (readonly)

When parsing was successful, then contains the output HTML - the input type-definition with types themselves replaced with links.



51
52
53
 
# File 'lib/jsduck/type_parser.rb', line 51

def out
  @out
end

Instance Method Details

#parse(str) ⇒ Object

Parses the type definition

<type> ::= <alteration-type>



71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/jsduck/type_parser.rb', line 71

def parse(str)
  @input = StringScanner.new(str)
  @error = :syntax
  @out = []

  # Return immediately if the base type doesn't match
  return false unless alteration_type

  # Concatenate all output
  @out = @out.join

  # Success if we have reached the end of input
  return @input.eos?
end