ether-code 0.1.6 → 0.1.8

package/parsers/ast-ruby.js

@@ -1,895 +0,0 @@
-class ASTNode {
-    constructor(type, loc = null) {
-        this.type = type
-        this.loc = loc
-    }
-}
-
-class Program extends ASTNode {
-    constructor(body = [], loc = null) {
-        super('Program', loc)
-        this.body = body
-    }
-}
-
-class Identifier extends ASTNode {
-    constructor(name, loc = null) {
-        super('Identifier', loc)
-        this.name = name
-    }
-}
-
-class InstanceVariable extends ASTNode {
-    constructor(name, loc = null) {
-        super('InstanceVariable', loc)
-        this.name = name
-    }
-}
-
-class ClassVariable extends ASTNode {
-    constructor(name, loc = null) {
-        super('ClassVariable', loc)
-        this.name = name
-    }
-}
-
-class GlobalVariable extends ASTNode {
-    constructor(name, loc = null) {
-        super('GlobalVariable', loc)
-        this.name = name
-    }
-}
-
-class Constant extends ASTNode {
-    constructor(name, loc = null) {
-        super('Constant', loc)
-        this.name = name
-    }
-}
-
-class ScopedConstant extends ASTNode {
-    constructor(scope, name, loc = null) {
-        super('ScopedConstant', loc)
-        this.scope = scope
-        this.name = name
-    }
-}
-
-class Symbol extends ASTNode {
-    constructor(value, loc = null) {
-        super('Symbol', loc)
-        this.value = value
-    }
-}
-
-class StringLiteral extends ASTNode {
-    constructor(value, raw = null, interpolated = false, loc = null) {
-        super('StringLiteral', loc)
-        this.value = value
-        this.raw = raw
-        this.interpolated = interpolated
-    }
-}
-
-class InterpolatedString extends ASTNode {
-    constructor(parts = [], loc = null) {
-        super('InterpolatedString', loc)
-        this.parts = parts
-    }
-}
-
-class StringPart extends ASTNode {
-    constructor(value, loc = null) {
-        super('StringPart', loc)
-        this.value = value
-    }
-}
-
-class InterpolationPart extends ASTNode {
-    constructor(expression, loc = null) {
-        super('InterpolationPart', loc)
-        this.expression = expression
-    }
-}
-
-class NumericLiteral extends ASTNode {
-    constructor(value, raw = null, loc = null) {
-        super('NumericLiteral', loc)
-        this.value = value
-        this.raw = raw
-    }
-}
-
-class FloatLiteral extends ASTNode {
-    constructor(value, raw = null, loc = null) {
-        super('FloatLiteral', loc)
-        this.value = value
-        this.raw = raw
-    }
-}
-
-class RationalLiteral extends ASTNode {
-    constructor(value, raw = null, loc = null) {
-        super('RationalLiteral', loc)
-        this.value = value
-        this.raw = raw
-    }
-}
-
-class ComplexLiteral extends ASTNode {
-    constructor(value, raw = null, loc = null) {
-        super('ComplexLiteral', loc)
-        this.value = value
-        this.raw = raw
-    }
-}
-
-class BooleanLiteral extends ASTNode {
-    constructor(value, loc = null) {
-        super('BooleanLiteral', loc)
-        this.value = value
-    }
-}
-
-class NilLiteral extends ASTNode {
-    constructor(loc = null) {
-        super('NilLiteral', loc)
-    }
-}
-
-class ArrayLiteral extends ASTNode {
-    constructor(elements = [], loc = null) {
-        super('ArrayLiteral', loc)
-        this.elements = elements
-    }
-}
-
-class HashLiteral extends ASTNode {
-    constructor(pairs = [], loc = null) {
-        super('HashLiteral', loc)
-        this.pairs = pairs
-    }
-}
-
-class HashPair extends ASTNode {
-    constructor(key, value, loc = null) {
-        super('HashPair', loc)
-        this.key = key
-        this.value = value
-    }
-}
-
-class RangeLiteral extends ASTNode {
-    constructor(start, end, exclusive = false, loc = null) {
-        super('RangeLiteral', loc)
-        this.start = start
-        this.end = end
-        this.exclusive = exclusive
-    }
-}
-
-class RegexpLiteral extends ASTNode {
-    constructor(pattern, flags = '', loc = null) {
-        super('RegexpLiteral', loc)
-        this.pattern = pattern
-        this.flags = flags
-    }
-}
-
-class PercentArray extends ASTNode {
-    constructor(elements = [], type = 'w', loc = null) {
-        super('PercentArray', loc)
-        this.elements = elements
-        this.type = type
-    }
-}
-
-class HeredocLiteral extends ASTNode {
-    constructor(content, delimiter, squiggly = false, loc = null) {
-        super('HeredocLiteral', loc)
-        this.content = content
-        this.delimiter = delimiter
-        this.squiggly = squiggly
-    }
-}
-
-class BinaryExpression extends ASTNode {
-    constructor(operator, left, right, loc = null) {
-        super('BinaryExpression', loc)
-        this.operator = operator
-        this.left = left
-        this.right = right
-    }
-}
-
-class UnaryExpression extends ASTNode {
-    constructor(operator, argument, prefix = true, loc = null) {
-        super('UnaryExpression', loc)
-        this.operator = operator
-        this.argument = argument
-        this.prefix = prefix
-    }
-}
-
-class AssignmentExpression extends ASTNode {
-    constructor(operator, left, right, loc = null) {
-        super('AssignmentExpression', loc)
-        this.operator = operator
-        this.left = left
-        this.right = right
-    }
-}
-
-class MultipleAssignment extends ASTNode {
-    constructor(targets = [], value, loc = null) {
-        super('MultipleAssignment', loc)
-        this.targets = targets
-        this.value = value
-    }
-}
-
-class SplatExpression extends ASTNode {
-    constructor(argument, loc = null) {
-        super('SplatExpression', loc)
-        this.argument = argument
-    }
-}
-
-class DoubleSplatExpression extends ASTNode {
-    constructor(argument, loc = null) {
-        super('DoubleSplatExpression', loc)
-        this.argument = argument
-    }
-}
-
-class ConditionalExpression extends ASTNode {
-    constructor(test, consequent, alternate, loc = null) {
-        super('ConditionalExpression', loc)
-        this.test = test
-        this.consequent = consequent
-        this.alternate = alternate
-    }
-}
-
-class LogicalExpression extends ASTNode {
-    constructor(operator, left, right, loc = null) {
-        super('LogicalExpression', loc)
-        this.operator = operator
-        this.left = left
-        this.right = right
-    }
-}
-
-class MethodCall extends ASTNode {
-    constructor(receiver, method, arguments_ = [], block = null, safeNavigation = false, loc = null) {
-        super('MethodCall', loc)
-        this.receiver = receiver
-        this.method = method
-        this.arguments = arguments_
-        this.block = block
-        this.safeNavigation = safeNavigation
-    }
-}
-
-class IndexAccess extends ASTNode {
-    constructor(object, index, loc = null) {
-        super('IndexAccess', loc)
-        this.object = object
-        this.index = index
-    }
-}
-
-class IndexAssignment extends ASTNode {
-    constructor(object, index, value, loc = null) {
-        super('IndexAssignment', loc)
-        this.object = object
-        this.index = index
-        this.value = value
-    }
-}
-
-class AttributeAccess extends ASTNode {
-    constructor(object, attribute, safeNavigation = false, loc = null) {
-        super('AttributeAccess', loc)
-        this.object = object
-        this.attribute = attribute
-        this.safeNavigation = safeNavigation
-    }
-}
-
-class AttributeAssignment extends ASTNode {
-    constructor(object, attribute, value, safeNavigation = false, loc = null) {
-        super('AttributeAssignment', loc)
-        this.object = object
-        this.attribute = attribute
-        this.value = value
-        this.safeNavigation = safeNavigation
-    }
-}
-
-class SuperCall extends ASTNode {
-    constructor(arguments_ = null, block = null, loc = null) {
-        super('SuperCall', loc)
-        this.arguments = arguments_
-        this.block = block
-    }
-}
-
-class YieldExpression extends ASTNode {
-    constructor(arguments_ = [], loc = null) {
-        super('YieldExpression', loc)
-        this.arguments = arguments_
-    }
-}
-
-class SelfExpression extends ASTNode {
-    constructor(loc = null) {
-        super('SelfExpression', loc)
-    }
-}
-
-class DefinedExpression extends ASTNode {
-    constructor(expression, loc = null) {
-        super('DefinedExpression', loc)
-        this.expression = expression
-    }
-}
-
-class NotExpression extends ASTNode {
-    constructor(argument, loc = null) {
-        super('NotExpression', loc)
-        this.argument = argument
-    }
-}
-
-class Block extends ASTNode {
-    constructor(parameters = [], body = [], loc = null) {
-        super('Block', loc)
-        this.parameters = parameters
-        this.body = body
-    }
-}
-
-class BlockParameter extends ASTNode {
-    constructor(name, defaultValue = null, splat = false, doubleSplat = false, blockArg = false, loc = null) {
-        super('BlockParameter', loc)
-        this.name = name
-        this.defaultValue = defaultValue
-        this.splat = splat
-        this.doubleSplat = doubleSplat
-        this.blockArg = blockArg
-    }
-}
-
-class ProcLiteral extends ASTNode {
-    constructor(parameters = [], body = [], loc = null) {
-        super('ProcLiteral', loc)
-        this.parameters = parameters
-        this.body = body
-    }
-}
-
-class LambdaLiteral extends ASTNode {
-    constructor(parameters = [], body = [], loc = null) {
-        super('LambdaLiteral', loc)
-        this.parameters = parameters
-        this.body = body
-    }
-}
-
-class MethodDefinition extends ASTNode {
-    constructor(name, parameters = [], body = [], singleton = null, loc = null) {
-        super('MethodDefinition', loc)
-        this.name = name
-        this.parameters = parameters
-        this.body = body
-        this.singleton = singleton
-    }
-}
-
-class MethodParameter extends ASTNode {
-    constructor(name, defaultValue = null, splat = false, doubleSplat = false, blockArg = false, keyword = false, loc = null) {
-        super('MethodParameter', loc)
-        this.name = name
-        this.defaultValue = defaultValue
-        this.splat = splat
-        this.doubleSplat = doubleSplat
-        this.blockArg = blockArg
-        this.keyword = keyword
-    }
-}
-
-class ClassDefinition extends ASTNode {
-    constructor(name, superclass = null, body = [], loc = null) {
-        super('ClassDefinition', loc)
-        this.name = name
-        this.superclass = superclass
-        this.body = body
-    }
-}
-
-class SingletonClass extends ASTNode {
-    constructor(object, body = [], loc = null) {
-        super('SingletonClass', loc)
-        this.object = object
-        this.body = body
-    }
-}
-
-class ModuleDefinition extends ASTNode {
-    constructor(name, body = [], loc = null) {
-        super('ModuleDefinition', loc)
-        this.name = name
-        this.body = body
-    }
-}
-
-class IncludeStatement extends ASTNode {
-    constructor(modules = [], loc = null) {
-        super('IncludeStatement', loc)
-        this.modules = modules
-    }
-}
-
-class ExtendStatement extends ASTNode {
-    constructor(modules = [], loc = null) {
-        super('ExtendStatement', loc)
-        this.modules = modules
-    }
-}
-
-class PrependStatement extends ASTNode {
-    constructor(modules = [], loc = null) {
-        super('PrependStatement', loc)
-        this.modules = modules
-    }
-}
-
-class AttrAccessor extends ASTNode {
-    constructor(type, attributes = [], loc = null) {
-        super('AttrAccessor', loc)
-        this.accessorType = type
-        this.attributes = attributes
-    }
-}
-
-class AliasStatement extends ASTNode {
-    constructor(newName, oldName, loc = null) {
-        super('AliasStatement', loc)
-        this.newName = newName
-        this.oldName = oldName
-    }
-}
-
-class UndefStatement extends ASTNode {
-    constructor(methods = [], loc = null) {
-        super('UndefStatement', loc)
-        this.methods = methods
-    }
-}
-
-class IfStatement extends ASTNode {
-    constructor(test, consequent = [], alternate = null, modifier = false, loc = null) {
-        super('IfStatement', loc)
-        this.test = test
-        this.consequent = consequent
-        this.alternate = alternate
-        this.modifier = modifier
-    }
-}
-
-class UnlessStatement extends ASTNode {
-    constructor(test, consequent = [], alternate = null, modifier = false, loc = null) {
-        super('UnlessStatement', loc)
-        this.test = test
-        this.consequent = consequent
-        this.alternate = alternate
-        this.modifier = modifier
-    }
-}
-
-class ElsifClause extends ASTNode {
-    constructor(test, consequent = [], loc = null) {
-        super('ElsifClause', loc)
-        this.test = test
-        this.consequent = consequent
-    }
-}
-
-class CaseStatement extends ASTNode {
-    constructor(expression, whens = [], elseBody = null, loc = null) {
-        super('CaseStatement', loc)
-        this.expression = expression
-        this.whens = whens
-        this.elseBody = elseBody
-    }
-}
-
-class WhenClause extends ASTNode {
-    constructor(conditions = [], body = [], loc = null) {
-        super('WhenClause', loc)
-        this.conditions = conditions
-        this.body = body
-    }
-}
-
-class CaseInStatement extends ASTNode {
-    constructor(expression, ins = [], elseBody = null, loc = null) {
-        super('CaseInStatement', loc)
-        this.expression = expression
-        this.ins = ins
-        this.elseBody = elseBody
-    }
-}
-
-class InClause extends ASTNode {
-    constructor(pattern, guard = null, body = [], loc = null) {
-        super('InClause', loc)
-        this.pattern = pattern
-        this.guard = guard
-        this.body = body
-    }
-}
-
-class ArrayPattern extends ASTNode {
-    constructor(elements = [], rest = null, loc = null) {
-        super('ArrayPattern', loc)
-        this.elements = elements
-        this.rest = rest
-    }
-}
-
-class HashPattern extends ASTNode {
-    constructor(pairs = [], rest = null, loc = null) {
-        super('HashPattern', loc)
-        this.pairs = pairs
-        this.rest = rest
-    }
-}
-
-class AlternativePattern extends ASTNode {
-    constructor(patterns = [], loc = null) {
-        super('AlternativePattern', loc)
-        this.patterns = patterns
-    }
-}
-
-class AsPattern extends ASTNode {
-    constructor(pattern, variable, loc = null) {
-        super('AsPattern', loc)
-        this.pattern = pattern
-        this.variable = variable
-    }
-}
-
-class PinExpression extends ASTNode {
-    constructor(variable, loc = null) {
-        super('PinExpression', loc)
-        this.variable = variable
-    }
-}
-
-class WhileStatement extends ASTNode {
-    constructor(test, body = [], modifier = false, loc = null) {
-        super('WhileStatement', loc)
-        this.test = test
-        this.body = body
-        this.modifier = modifier
-    }
-}
-
-class UntilStatement extends ASTNode {
-    constructor(test, body = [], modifier = false, loc = null) {
-        super('UntilStatement', loc)
-        this.test = test
-        this.body = body
-        this.modifier = modifier
-    }
-}
-
-class ForStatement extends ASTNode {
-    constructor(variable, iterable, body = [], loc = null) {
-        super('ForStatement', loc)
-        this.variable = variable
-        this.iterable = iterable
-        this.body = body
-    }
-}
-
-class LoopStatement extends ASTNode {
-    constructor(body = [], loc = null) {
-        super('LoopStatement', loc)
-        this.body = body
-    }
-}
-
-class BreakStatement extends ASTNode {
-    constructor(value = null, loc = null) {
-        super('BreakStatement', loc)
-        this.value = value
-    }
-}
-
-class NextStatement extends ASTNode {
-    constructor(value = null, loc = null) {
-        super('NextStatement', loc)
-        this.value = value
-    }
-}
-
-class RedoStatement extends ASTNode {
-    constructor(loc = null) {
-        super('RedoStatement', loc)
-    }
-}
-
-class RetryStatement extends ASTNode {
-    constructor(loc = null) {
-        super('RetryStatement', loc)
-    }
-}
-
-class ReturnStatement extends ASTNode {
-    constructor(value = null, loc = null) {
-        super('ReturnStatement', loc)
-        this.value = value
-    }
-}
-
-class BeginBlock extends ASTNode {
-    constructor(body = [], rescues = [], elseBody = null, ensure = null, loc = null) {
-        super('BeginBlock', loc)
-        this.body = body
-        this.rescues = rescues
-        this.elseBody = elseBody
-        this.ensure = ensure
-    }
-}
-
-class RescueClause extends ASTNode {
-    constructor(exceptionTypes = [], variable = null, body = [], loc = null) {
-        super('RescueClause', loc)
-        this.exceptionTypes = exceptionTypes
-        this.variable = variable
-        this.body = body
-    }
-}
-
-class EnsureClause extends ASTNode {
-    constructor(body = [], loc = null) {
-        super('EnsureClause', loc)
-        this.body = body
-    }
-}
-
-class RaiseStatement extends ASTNode {
-    constructor(exception = null, message = null, backtrace = null, loc = null) {
-        super('RaiseStatement', loc)
-        this.exception = exception
-        this.message = message
-        this.backtrace = backtrace
-    }
-}
-
-class RescueModifier extends ASTNode {
-    constructor(expression, rescue, loc = null) {
-        super('RescueModifier', loc)
-        this.expression = expression
-        this.rescue = rescue
-    }
-}
-
-class RequireStatement extends ASTNode {
-    constructor(path, relative = false, loc = null) {
-        super('RequireStatement', loc)
-        this.path = path
-        this.relative = relative
-    }
-}
-
-class LoadStatement extends ASTNode {
-    constructor(path, wrap = false, loc = null) {
-        super('LoadStatement', loc)
-        this.path = path
-        this.wrap = wrap
-    }
-}
-
-class BeginStatement extends ASTNode {
-    constructor(body = [], loc = null) {
-        super('BeginStatement', loc)
-        this.body = body
-    }
-}
-
-class EndStatement extends ASTNode {
-    constructor(body = [], loc = null) {
-        super('EndStatement', loc)
-        this.body = body
-    }
-}
-
-class ExpressionStatement extends ASTNode {
-    constructor(expression, loc = null) {
-        super('ExpressionStatement', loc)
-        this.expression = expression
-    }
-}
-
-class FlipFlop extends ASTNode {
-    constructor(start, end, exclusive = false, loc = null) {
-        super('FlipFlop', loc)
-        this.start = start
-        this.end = end
-        this.exclusive = exclusive
-    }
-}
-
-class MatchExpression extends ASTNode {
-    constructor(left, right, loc = null) {
-        super('MatchExpression', loc)
-        this.left = left
-        this.right = right
-    }
-}
-
-class NotMatchExpression extends ASTNode {
-    constructor(left, right, loc = null) {
-        super('NotMatchExpression', loc)
-        this.left = left
-        this.right = right
-    }
-}
-
-class BacktickLiteral extends ASTNode {
-    constructor(command, loc = null) {
-        super('BacktickLiteral', loc)
-        this.command = command
-    }
-}
-
-class ParenthesizedExpression extends ASTNode {
-    constructor(expression, loc = null) {
-        super('ParenthesizedExpression', loc)
-        this.expression = expression
-    }
-}
-
-class SafeNavigationCall extends ASTNode {
-    constructor(object, method, arguments_ = [], block = null, loc = null) {
-        super('SafeNavigationCall', loc)
-        this.object = object
-        this.method = method
-        this.arguments = arguments_
-        this.block = block
-    }
-}
-
-class Encoding extends ASTNode {
-    constructor(loc = null) {
-        super('Encoding', loc)
-    }
-}
-
-class File extends ASTNode {
-    constructor(loc = null) {
-        super('File', loc)
-    }
-}
-
-class Line extends ASTNode {
-    constructor(loc = null) {
-        super('Line', loc)
-    }
-}
-
-class EtherNaturalExpression extends ASTNode {
-    constructor(original, translated, loc = null) {
-        super('EtherNaturalExpression', loc)
-        this.original = original
-        this.translated = translated
-    }
-}
-
-module.exports = {
-    ASTNode,
-    Program,
-    Identifier,
-    InstanceVariable,
-    ClassVariable,
-    GlobalVariable,
-    Constant,
-    ScopedConstant,
-    Symbol,
-    StringLiteral,
-    InterpolatedString,
-    StringPart,
-    InterpolationPart,
-    NumericLiteral,
-    FloatLiteral,
-    RationalLiteral,
-    ComplexLiteral,
-    BooleanLiteral,
-    NilLiteral,
-    ArrayLiteral,
-    HashLiteral,
-    HashPair,
-    RangeLiteral,
-    RegexpLiteral,
-    PercentArray,
-    HeredocLiteral,
-    BinaryExpression,
-    UnaryExpression,
-    AssignmentExpression,
-    MultipleAssignment,
-    SplatExpression,
-    DoubleSplatExpression,
-    ConditionalExpression,
-    LogicalExpression,
-    MethodCall,
-    IndexAccess,
-    IndexAssignment,
-    AttributeAccess,
-    AttributeAssignment,
-    SuperCall,
-    YieldExpression,
-    SelfExpression,
-    DefinedExpression,
-    NotExpression,
-    Block,
-    BlockParameter,
-    ProcLiteral,
-    LambdaLiteral,
-    MethodDefinition,
-    MethodParameter,
-    ClassDefinition,
-    SingletonClass,
-    ModuleDefinition,
-    IncludeStatement,
-    ExtendStatement,
-    PrependStatement,
-    AttrAccessor,
-    AliasStatement,
-    UndefStatement,
-    IfStatement,
-    UnlessStatement,
-    ElsifClause,
-    CaseStatement,
-    WhenClause,
-    CaseInStatement,
-    InClause,
-    ArrayPattern,
-    HashPattern,
-    AlternativePattern,
-    AsPattern,
-    PinExpression,
-    WhileStatement,
-    UntilStatement,
-    ForStatement,
-    LoopStatement,
-    BreakStatement,
-    NextStatement,
-    RedoStatement,
-    RetryStatement,
-    ReturnStatement,
-    BeginBlock,
-    RescueClause,
-    EnsureClause,
-    RaiseStatement,
-    RescueModifier,
-    RequireStatement,
-    LoadStatement,
-    BeginStatement,
-    EndStatement,
-    ExpressionStatement,
-    FlipFlop,
-    MatchExpression,
-    NotMatchExpression,
-    BacktickLiteral,
-    ParenthesizedExpression,
-    SafeNavigationCall,
-    Encoding,
-    File,
-    Line,
-    EtherNaturalExpression
-}