New approach

Author: Stig Otnes Kolstad

event-stream.js

@@ -0,0 +1,22 @@
+const { Transform } = require('stream')
+const EventEmitter = require('events')
+
+function EventStream (patternMap) {
+  return new Transform({
+    transform(chunk, encoding, done) {
+      const str = chunk.toString('utf8')
+      for ([pattern, fn] of patternMap) {
+        const result = pattern.exec(str)
+        if (result) {
+          fn(result)
+          // Stop looking after first match
+          break;
+        }
+      }
+      done()
+    }
+  })
+}
+
+module.exports = EventStream
+

irc.js

@@ -1,33 +1,88 @@
-const Emitter = require('events')
-const Transform = require('stream').Transform
-
-const patternMatch = (matchers) => {
-  return es.map((data, cb) => {
-    for ([pattern, fn] of matchers) {
-      const result = pattern.exec(data)
-      if (result) {
-        fn(result)
-        return
-      }
+const LineBuffer = require('./line-buffer')
+const EventStream = require('./event-stream')
+const { Socket, createServer } = require('net')
+
+class Client extends Socket {
+  constructor (options) {
+    super(options)
+    this.setEncoding('utf8')
+
+    if (options.dryRun) {
+      const serv = createServer().listen(11337)
+      serv.on('connection', s => s.on('data', (data) => console.log('SERVER', data)))
+      Object.assign(options, {host: 'localhost', port: 11337})
     }
-  })
-}
+    this.connect(options)
+
+    this.on('connect', () => this._identify(options.nick))
+    this.on('ping', (host) => this.send(`PONG ${host}`))
+    
+    this
+      .pipe(new LineBuffer())
+      .pipe(EventStream([
+        [ /PING (\S+)/, ([, hostname]) => this.emit('ping', {hostname}) ],
+        [ /^(\S+) PRIVMSG (\S+) :(.+)/, ([, from, to, msg]) => this.emit('msg', {from, to, msg}) ],
+        [ /^\S+ 376/, () => this.emit('ready') ], // End of MOTD
+        [ /^\S+ 433/, () => this.emit('error', 'Nickname in use') ],
+        [ /^\S+ 451/, () => this.emit('error', 'Not registered') ],
+      ]))
+  }
 
-const emitter = new Emitter()
-const emit = emitter.emit 
+  send (msg, cb) {
+    super.write(`${msg}\r\n`, cb)
+    console.log('***', msg)
+  }
 
-const matchers = [
-  [ /PING (\S+)/, ([, hostname]) => emit('ping', {hostname}) ],
-  [ /^(\S+) PRIVMSG (\S+) !(.+))/, (from, to, msg) => emit('msg', {from, to, msg}) ],
-]
+  msg (to, text) {
+    this.send(`PRIVMSG ${to} :${text}`)
+  }
 
-module.exports = emitter
+  join (chan) {
+    this.send(`JOIN ${chan}`)
+  }
+
+  nick (nick) {
+    this.send(`NICK ${nick}`)
+  }
+
+  quit (msg) {
+    this.send(`QUIT :${msg}`)
+  }
+
+  _identify (nick) {
+    this.send(`USER ${nick} * * :${nick}`) 
+    this.nick(nick)
+  }
+}
 
 if (!module.parent) {
-  //socket
+  const client = new Client({
+    host: 'chat.freenode.net',
+    port: 6667,
+    nick: 'sshowfojs',
+    dryRun: true
+  })
+  const chan = '#hackeriet'
+
+  client.pipe(process.stdout)
+
   process.stdin
-    .pipe(es.split())
-    .pipe(patternMatch(matchers))
-    .pipe(process.stdout)
+    .pipe(new LineBuffer())
+    .on('data', (line) => client.send(`PRIVMSG ${chan} :${line}`))
+
+  client.on('ready', () => client.join(chan))
+  client.on('msg', (msg) => console.log(msg))
+  client.on('end', () => process.exit(0))
+
+  let quitAttempts = 0
+  process.on('SIGINT', () => {
+    if (++quitAttempts > 1) {
+      process.exit(1)
+    }
+
+    client.send('QUIT :quitting', () => {
+      console.log('Quit successfully')
+    })
+  })
 }
 

line-buffer.js

@@ -0,0 +1,67 @@
+/*
+
+This module splits an incoming text stream by newline \n, and buffers
+text without a newline until an additional newline comes along, or on
+before the stream is closed.
+
+*/
+
+const Emitter = require('events')
+const { Transform } = require('stream')
+
+const EOL = '\n'
+
+class LineBuffer extends Transform {
+  constructor () {
+    super({
+      // Split streaming text into single line chunks
+      transform: (chunk, enc, done) => {
+        const str = this.buf + chunk.toString()
+        this.buf = ''
+        const parts = str.split(/\r?\n/)
+
+        // Emit lines one by one
+        while (parts.length > 1) {
+          const line = parts.shift()
+          this.push(line + EOL)
+        }
+
+        // Buffer text that doesn't have an EOL.
+        // The first item of the array may be empty, which is okay.
+        this.buf += parts[0]
+        done(null)
+      },
+
+      // Empty the buffer before closing stream
+      flush: (done) => {
+        this.push(this.buf + EOL)
+        this.buf = ''
+        done(null)
+      }
+    })
+
+    // Initialise an empty buffer
+    this.buf = ''
+
+    // TODO: Move to a test instead. Doesn't need to be here.
+    this.on('end', () => {
+      if (this.buf.length) {
+        console.error('Stream ended with text still in buffer')
+      }
+    })
+  }
+}
+
+module.exports = LineBuffer
+
+// TEST
+if (!module.parent) {
+
+  const lb = new LineBuffer()
+  lb.pipe(process.stdout)
+
+  lb.write('first line\nsecond line\nand some text with no newline')
+  lb.write(', but here the newline comes\n')
+  lb.end('last and end\n\n')
+}
+