Added tests and multiple filters and outputs

Author: simc

CHANGELOG.md

@@ -1,12 +1,16 @@
+## 0.7.0
+- Added `ProductionFilter`, `FileOutput`, `MemoryOutput`, `SimplePrinter`
+- Breaking: Changed `LogFilter`, `LogPrinter` and `LogOutput`
+
 ## 0.6.0
-- Add option to output timestamp
-- Add option to disable color
-- Add `LogOutput`
+- Added option to output timestamp
+- Added option to disable color
+- Added `LogOutput`
 - Behaviour change of `LogPrinter`
 - Remove dependency
 
 ## 0.5.0
-- Add emojis
+- Added emojis
 - `LogFilter` is a class now
 
 ## 0.4.0

README.md

@@ -1,6 +1,4 @@
-<img src="https://raw.githubusercontent.com/leisim/logger/master/art/logo.svg?sanitize=true" width="200"/>
-
-<hr>
+# Logger
 
 [![Travis](https://img.shields.io/travis/com/leisim/logger/master.svg)](https://travis-ci.com/leisim/logger) [![Version](https://img.shields.io/pub/v/logger.svg)](https://pub.dev/packages/logger) ![Runtime](https://img.shields.io/badge/dart-%3E%3D2.1-brightgreen.svg) ![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg?style=flat)
 
@@ -85,14 +83,14 @@ var logger = Logger(
 
 ## LogFilter
 
-The `LogFilter` decides which logs should be shown and which don't.
+The `LogFilter` decides which log events should be shown and which don't.<br>
 The default implementation (`DebugFilter`) shows all logs with `level >= Logger.level` while in debug mode. In release mode all logs are omitted.
 
 You can create your own `LogFilter` like this:
 ```dart
 class MyFilter extends LogFilter {
   @override
-  bool shouldLog(Level level, dynamic message, [dynamic error, StackTrace stackTrace]) {
+  bool shouldLog(LogEvent event) {
     return true;
   }
 }
@@ -102,13 +100,15 @@ This will show all logs even in release mode. (**NOT** a good idea)
 
 ## LogPrinter
 
-You can implement your own `LogPrinter`. This gives you maximum flexibility. A very basic printer could look like this:
+The `LogPrinter` creates and formats the output, which is then sent to the `LogOutput`.<br>
+You can implement your own `LogPrinter`. This gives you maximum flexibility.
 
+A very basic printer could look like this:
 ```dart
 class MyPrinter extends LogPrinter {
   @override
-  void log(Level level, dynamic message, dynamic error, StackTrace stackTrace) {
-    println(message);
+  void log(LogEvent event) {
+    println(event.message);
   }
 }
 ```
@@ -120,13 +120,14 @@ If you created a cool `LogPrinter` which might be helpful to others, feel free t
 
 ## LogOutput
 
-`LogOutput` sends the log lines to the desired destination. The default implementation (`ConsoleOutput`) send every line to the system console.
+`LogOutput` sends the log lines to the desired destination.<br>
+The default implementation (`ConsoleOutput`) send every line to the system console.
 
 ```dart
 class ConsoleOutput extends LogOutput {
   @override
-  void output(Level level, List<String> lines) {
-    for (var line in lines) {
+  void output(OutputEvent event) {
+    for (var line in event.lines) {
       print(line);
     }
   }

art/logo.svg

@@ -22,4 +22,6 @@ void demo() {
   logger.e("Error! Something bad happened", "Test Error");
 
   loggerNoStack.v({"key": 5, "value": "something"});
+
+  print("Test\nTest2");
 }

example/lib/main.dart

@@ -1,10 +1,22 @@
 /// Small, easy to use and extensible logger which prints beautiful logs.
 library logger;
 
+import 'dart:collection';
 import 'dart:convert';
+import 'dart:io';
+import 'package:meta/meta.dart';
+
 import 'src/ansi_color.dart';
 
-part 'src/default/console_output.dart';
-part 'src/default/debug_filter.dart';
-part 'src/default/pretty_printer.dart';
+part 'src/filters/debug_filter.dart';
+part 'src/filters/production_filter.dart';
+part 'src/outputs/console_output.dart';
+part 'src/outputs/file_output.dart';
+part 'src/outputs/memory_output.dart';
+part 'src/printers/pretty_printer.dart';
+part 'src/printers/simple_printer.dart';
+
+part 'src/log_filter.dart';
+part 'src/log_output.dart';
+part 'src/log_printer.dart';
 part 'src/logger.dart';

lib/logger.dart

@@ -2,14 +2,14 @@ part of logger;
 
 /// Default implementation of [LogFilter].
 ///
-/// Shows all logs with `level >= Logger.level` while in debug mode. In release
+/// Prints all logs with `level >= Logger.level` while in debug mode. In release
 /// mode all logs are omitted.
 class DebugFilter extends LogFilter {
   @override
-  bool shouldLog(Level level, message, [error, StackTrace stackTrace]) {
+  bool shouldLog(LogEvent event) {
     var shouldLog = false;
     assert(() {
-      if (level.index >= Logger.level.index) {
+      if (event.level.index >= Logger.level.index) {
         shouldLog = true;
       }
       return true;

lib/src/default/debug_filter.dart renamed to lib/src/filters/debug_filter.dart

@@ -0,0 +1,9 @@
+part of logger;
+
+/// Prints all logs with `level >= Logger.level` even in production.
+class ProductionFilter extends LogFilter {
+  @override
+  bool shouldLog(LogEvent event) {
+    return event.level.index >= Logger.level.index;
+  }
+}

lib/src/filters/production_filter.dart

@@ -0,0 +1,17 @@
+part of logger;
+
+/// An abstract filter of log messages.
+///
+/// You can implement your own `LogFilter` or use [DebugFilter].
+/// Every implementation should consider [Logger.level].
+abstract class LogFilter {
+  void init() {}
+
+  /// Is called every time a new log message is sent and decides if
+  /// it will be printed or canceled.
+  ///
+  /// Returns `true` if the message should be logged.
+  bool shouldLog(LogEvent event);
+
+  void destroy() {}
+}

lib/src/log_filter.dart

@@ -0,0 +1,14 @@
+part of logger;
+
+/// Log output receives a [OutputEvent] from [LogPrinter] and sends it to the
+/// desired destination.
+///
+/// This can be an output stream, a file or a network target. [LogOutput] may
+/// cache multiple log messages.
+abstract class LogOutput {
+  void init() {}
+
+  void output(OutputEvent event);
+
+  void destroy() {}
+}

lib/src/log_output.dart

@@ -0,0 +1,25 @@
+part of logger;
+
+/// An abstract handler of log events.
+///
+/// A log printer creates and formats the output, which is then sent to
+/// [LogOutput]. Every implementation has to use the [LogPrinter.println]
+/// method to send the output.
+///
+/// You can implement a `LogPrinter` from scratch or extend [PrettyPrinter].
+abstract class LogPrinter {
+  List<String> _buffer;
+
+  void init() {}
+
+  /// Is called every time a new [LogEvent] is sent and handles printing or
+  /// storing the message.
+  void log(LogEvent event);
+
+  void destroy() {}
+
+  /// Sends a line to the [LogOutput].
+  void println(String line) {
+    _buffer.add(line);
+  }
+}