lib/src/barback/foreign_transformer.dart

// Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'dart:async';
import 'dart:isolate';

import 'package:barback/barback.dart';

import '../asset/dart/serialize.dart';
import 'excluding_aggregate_transformer.dart';
import 'excluding_transformer.dart';
import 'transformer_config.dart';

/// A wrapper for a transformer that's in a different isolate.
class _ForeignTransformer extends Transformer {
  /// The port with which we communicate with the child isolate.
  ///
  /// This port and all messages sent across it are specific to this
  /// transformer.
  final SendPort _port;

  /// The result of calling [toString] on the transformer in the isolate.
  final String _toString;

  _ForeignTransformer(Map map)
      : _port = map['port'],
        _toString = map['toString'];

  Future<bool> isPrimary(AssetId id) {
    return call(_port, {'type': 'isPrimary', 'id': serializeId(id)});
  }

  Future apply(Transform transform) {
    return call(
        _port, {'type': 'apply', 'transform': serializeTransform(transform)});
  }

  String toString() => _toString;
}

class _ForeignDeclaringTransformer extends _ForeignTransformer
    implements DeclaringTransformer {
  _ForeignDeclaringTransformer(Map map) : super(map);

  Future declareOutputs(DeclaringTransform transform) {
    return call(_port, {
      'type': 'declareOutputs',
      'transform': serializeDeclaringTransform(transform)
    });
  }
}

class _ForeignLazyTransformer extends _ForeignDeclaringTransformer
    implements LazyTransformer {
  _ForeignLazyTransformer(Map map) : super(map);
}

/// A wrapper for an aggregate transformer that's in a different isolate.
class _ForeignAggregateTransformer extends AggregateTransformer {
  /// The port with which we communicate with the child isolate.
  ///
  /// This port and all messages sent across it are specific to this
  /// transformer.
  final SendPort _port;

  /// The result of calling [toString] on the transformer in the isolate.
  final String _toString;

  _ForeignAggregateTransformer(Map map)
      : _port = map['port'],
        _toString = map['toString'];

  Future<String> classifyPrimary(AssetId id) {
    return call(_port, {'type': 'classifyPrimary', 'id': serializeId(id)});
  }

  Future apply(AggregateTransform transform) {
    return call(_port,
        {'type': 'apply', 'transform': serializeAggregateTransform(transform)});
  }

  String toString() => _toString;
}

class _ForeignDeclaringAggregateTransformer extends _ForeignAggregateTransformer
    implements DeclaringAggregateTransformer {
  _ForeignDeclaringAggregateTransformer(Map map) : super(map);

  Future declareOutputs(DeclaringAggregateTransform transform) {
    return call(_port, {
      'type': 'declareOutputs',
      'transform': serializeDeclaringAggregateTransform(transform)
    });
  }
}

class _ForeignLazyAggregateTransformer
    extends _ForeignDeclaringAggregateTransformer
    implements LazyAggregateTransformer {
  _ForeignLazyAggregateTransformer(Map map) : super(map);
}

/// A wrapper for a transformer group that's in a different isolate.
class _ForeignGroup implements TransformerGroup {
  final Iterable<Iterable> phases;

  /// The result of calling [toString] on the transformer group in the isolate.
  final String _toString;

  _ForeignGroup(TransformerConfig config, Map map)
      : phases = (map['phases'] as List).map((phase) {
          return (phase as List)
              .map((transformer) =>
                  deserializeTransformerLike(transformer, config))
              .toList();
        }).toList(),
        _toString = map['toString'];

  String toString() => _toString;
}

/// Converts a serializable map into a [Transformer], an [AggregateTransformer],
/// or a [TransformerGroup].
deserializeTransformerLike(Map map, TransformerConfig config) {
  var transformer;
  switch (map['type']) {
    case 'TransformerGroup':
      return new _ForeignGroup(config, map);
    case 'Transformer':
      transformer = new _ForeignTransformer(map);
      break;
    case 'DeclaringTransformer':
      transformer = new _ForeignDeclaringTransformer(map);
      break;
    case 'LazyTransformer':
      transformer = new _ForeignLazyTransformer(map);
      break;
    case 'AggregateTransformer':
      transformer = new _ForeignAggregateTransformer(map);
      break;
    case 'DeclaringAggregateTransformer':
      transformer = new _ForeignDeclaringAggregateTransformer(map);
      break;
    case 'LazyAggregateTransformer':
      transformer = new _ForeignLazyAggregateTransformer(map);
      break;
    default:
      assert(false);
  }

  if (transformer is Transformer) {
    return ExcludingTransformer.wrap(transformer, config);
  } else {
    assert(transformer is AggregateTransformer);
    return ExcludingAggregateTransformer.wrap(transformer, config);
  }
}