netrc-parser/lib/machine.js

'use strict'
Object.defineProperty(exports, '__esModule', { value: true })
const tslib_1 = require('tslib')
const Token = require('./token')
// export abstract class Token {
//   public pre: string
//   public post: string
//   public _tokens: Token[] = []
//   constructor (opts: Options) {
//     this.pre = pre
//     this.post = post
//   }
//   get content(): string { return [this.pre, this._content, this.post, ...this.elements.map(e => e.content)].join('') }
//   protected get _content() { return '' }
// }
class Prop extends Token {
  constructor(opts) {
    super(opts)
    this.type = 'prop'
    this.name = opts.name
    this.value = opts.value
  }
  get _content() {
    return `${this.name} ${this.value}`
  }
}
exports.Prop = Prop
class MachineBase extends Token {
  constructor(_a = {}) {
    var { login, password, account } = _a,
      opts = tslib_1.__rest(_a, ['login', 'password', 'account'])
    super(opts)
    if (login) this.login = login
    if (password) this.password = password
    if (account) this.account = account
  }
  get login() {
    return this.getProp('login')
  }
  get password() {
    return this.getProp('password')
  }
  get account() {
    return this.getProp('account')
  }
  set login(v) {
    this.setProp('login', v)
  }
  set password(v) {
    this.setProp('password', v)
  }
  set account(v) {
    this.setProp('account', v)
  }
  addProp(prop) {
    this.elements.push(prop)
  }
  getProp(name) {
    const p = this.elements.find(p => p.name === name)
    return p && p.value
  }
  setProp(name, value) {
    if (!value) {
      this.elements = this.elements.filter(p => p.name === name)
      return
    }
    let p = this.elements.find(p => p.name === name)
    if (p) {
      p.value = value
    } else {
      p = new Prop({ name, value })
      this.elements.push(p)
    }
    console.log(this.elements)
  }
}
exports.MachineBase = MachineBase
class Machine extends MachineBase {
  constructor(_a) {
    var { host } = _a,
      opts = tslib_1.__rest(_a, ['host'])
    super(opts)
    this.type = 'machine'
    this.host = host
  }
  get _content() {
    return `machine ${this.host}`
  }
}
exports.Machine = Machine
class DefaultMachine extends MachineBase {
  constructor() {
    super(...arguments)
    this.type = 'default'
  }
  get _content() {
    return 'default'
  }
}
exports.DefaultMachine = DefaultMachine
function machinesProxy(tokens = []) {
  return new Proxy(
    {},
    {
      get: (_, host) => {
        if (typeof host !== 'string') return tokens[host]
        return tokens.find(m => m.type === 'machine' && m.host === host)
      },
      set: (_, host, value) => {
        tokens.push(new Machine(Object.assign({}, value, { host })))
        return true
      },
      has: (_, host) => {
        if (typeof host !== 'string') return !!tokens[host]
        return !!tokens.find(m => m.type === 'machine' && m.host === host)
      },
      deleteProperty: (_, host) => {
        const idx = tokens.findIndex(m => m.type === 'machine' && m.host === host)
        if (idx === -1) return false
        tokens.splice(idx, 1)
        return true
      },
    },
  )
}
exports.machinesProxy = machinesProxy