nixfilter/filter.coffee

Simplify the development of (UNIX) "Filters"

'use strict'

# Import/Require the "argparse" module
argparse = require('argparse')

# Import the EventEmitter class from the "events" module
Event_Emitter = require('events')

# Import/require the local "reader" module
reader = require('./reader')

# Import/require the local "utils" module
utils = require('./utils')

# Import/require the local "writer" module
writer = require('./writer')

Filter = utils.extend Event_Emitter,

	# The default description
	description: 'No description available'

	# The default add_arguments(argument_parser) function: A no-op function
	add_arguments: (argument_parser) ->

	# Setup an ArgumentParser for this module and return it
	get_argument_parser: ->
		argument_parser = new argparse.ArgumentParser
			description: @description
		@add_arguments(argument_parser)
		argument_parser

	# The default setup(args) function: A no-op function
	setup: (args) ->

	# The default terminate() function: A no-op function
	terminate: ->

	stop: ->
		@emit 'stopping'
		return

	input_reader: reader.line('utf8')

	output_writer: writer.line('utf8')

	run: (@args) ->
		if not @args
			@args = @get_argument_parser().parseArgs()
		@emit 'starting'
		Promise.resolve(@setup(@args))
		.then =>
			if (@input_reader)
				# The filter is a sink, it consumes input data
				@input_stream = process.stdin
				@input_stream.on 'data', @input_reader(@on_input.bind(@))
				@input_stream.on 'close', =>
					@stop()
					return
			if (@output_writer)
				# The filter is a source, it produces output data
				@output_stream = process.stdout
				@output = @output_writer (output_bytes) =>
					@output_stream.write(output_bytes)
					return
				@output_stream.on 'close', =>
					@stop()
					return
			@emit 'started'
			new Promise (resolve, reject) =>
				@once 'stopping', =>
					Promise.resolve(@terminate())
					.then =>
						@emit 'stopped'
						resolve()
						return
					.catch (error) =>
						reject(error)
						return
					return
				return

create_filter_class = (filter_specification) ->
	utils.extend(Filter, filter_specification)

run_filter_class = (Filter_Class) ->
	filter = new Filter_Class()
	filter.run()

setup_filter = ->
	args = Array.prototype.slice.call(arguments)
	filter_specification = args.pop()
	filter_module = args.pop()
	Filter_Class = create_filter_class(filter_specification)
	if filter_module
		filter_module.exports.Filter = Filter_Class
		if (require.main is filter_module)
			run_filter_class(Filter_Class)
			.catch (error) ->
				console.error(error)
				process.exit(1)
	Filter_Class

# What this module exports
module.exports =
	setup_filter: setup_filter