fix all the indenting

Author: oxinabox

README.md

@@ -39,12 +39,12 @@ If it was to be defined in a compositional way,
 we would write something along the lines of:
 ```
 ConsoleLogger(stream, min_level) =
-	MinLevelLogger(
-		ActiveFilteredLogger(max_log_filter,
-			PureConsoleLogger(stream)
-		),
-		min_level
-	)
+    MinLevelLogger(
+        ActiveFilteredLogger(max_log_filter,
+            PureConsoleLogger(stream)
+        ),
+        min_level
+    )
 ```
 
 
@@ -60,7 +60,7 @@ For full details, see the [Julia documentation on Logging](https://docs.julialan
 To use a `logger` in a given scope do
 ```
 with_logger(logger) do
-	#things
+    #things
 end
 ```
 
@@ -119,17 +119,17 @@ and warnings and above to another.
 julia> using Logging; using LoggingExtras;
 
 julia> demux_logger = DemuxLogger(
-	MinLevelLogger(FileLogger("info.log"), Logging.Info),
-	MinLevelLogger(FileLogger("warn.log"), Logging.Warn),
+    MinLevelLogger(FileLogger("info.log"), Logging.Info),
+    MinLevelLogger(FileLogger("warn.log"), Logging.Warn),
     include_current_global=false
 );
 
 
 julia> with_logger(demux_logger) do
-	@warn("It is bad")
-	@info("normal stuff")
-	@error("THE WORSE THING")
-	@debug("it is chill")
+    @warn("It is bad")
+    @info("normal stuff")
+    @error("THE WORSE THING")
+    @debug("it is chill")
 end
 
 shell>  cat warn.log
@@ -160,17 +160,17 @@ We want to filter to only log strings staring with `"Yo Dawg!"`.
 
 ```
 julia> function yodawg_filter(log_args)
-	startswith(log_args.message, "Yo Dawg!")
+    startswith(log_args.message, "Yo Dawg!")
 end
  yodawg_filter (generic function with 1 method)
 
 julia> filtered_logger = ActiveFilteredLogger(yodawg_filter, global_logger());
 
 julia> with_logger(filtered_logger) do
-	@info "Boring message"
-	@warn "Yo Dawg! it is bad"
-	@info "Another boring message"
-	@info "Yo Dawg! it is all good"
+    @info "Boring message"
+    @warn "Yo Dawg! it is bad"
+    @info "Another boring message"
+    @info "Yo Dawg! it is all good"
 end
 ┌ Warning: Yo Dawg! it is bad
 └ @ Main REPL[28]:3
@@ -307,12 +307,12 @@ using HTTP
 
 transformer_logger(global_logger()) do log
     if log._module == HTTP && log.level=Logging.Debug
-	    # Merge can be used to construct a new NamedTuple
-		# which effectively is the overwriting of fields of a NamedTuple
-		return merge(log, (; level=Logging.Info))
-	else
-		return log
-	end
+        # Merge can be used to construct a new NamedTuple
+        # which effectively is the overwriting of fields of a NamedTuple
+        return merge(log, (; level=Logging.Info))
+    else
+        return log
+    end
 end
 
 global_logger(transformer_logger)

src/LoggingExtras.jl

@@ -6,7 +6,7 @@ using Base.CoreLogging:
 
 import Base.CoreLogging:
     AbstractLogger, SimpleLogger,
-	handle_message, shouldlog, min_enabled_level, catch_exceptions
+    handle_message, shouldlog, min_enabled_level, catch_exceptions
 
 export demux_global_logger,
     DemuxLogger, TransformerLogger, FileLogger,

src/activefiltered.jl

@@ -1,5 +1,5 @@
 """
-	ActiveFilteredLogger(filter, logger)
+    ActiveFilteredLogger(filter, logger)
 
 Wraps `logger` in an active filter.
 While loggers intrinsictally have in built filtering mechanisms.
@@ -20,17 +20,17 @@ As input it will be given a named tuple with the following fields:
 See `?LoggingExtra.handle_message_args` for more information on what each is.
 """
 struct ActiveFilteredLogger{T <: AbstractLogger, F} <: AbstractLogger
-	filter::F
-	logger::T
+    filter::F
+    logger::T
 end
 
 
 function handle_message(logger::ActiveFilteredLogger, args...; kwargs...)
     log_args = handle_message_args(args...; kwargs...)
     if comp_handle_message_check(logger.logger, args...; kwargs...)
         if logger.filter(log_args)
-		    handle_message(logger.logger, args...; kwargs...)
-	    end
+            handle_message(logger.logger, args...; kwargs...)
+        end
     end
 end
 
@@ -67,5 +67,3 @@ function handle_message_args(args...; kwargs...)
     fieldvals = (args..., kwargs)
     return NamedTuple{fieldnames, typeof(fieldvals)}(fieldvals)
 end
-
-

src/demux.jl

@@ -1,5 +1,5 @@
 struct DemuxLogger <: AbstractLogger
-	loggers::Vector{AbstractLogger}
+    loggers::Vector{AbstractLogger}
 end
 
 
@@ -15,28 +15,28 @@ Normally this would be the ConsoleLogger in the REPL etc.
 """
 function DemuxLogger(loggers::Vararg{AbstractLogger}; include_current_global=true)
     loggers = Vector{AbstractLogger}(collect(loggers))
-	if include_current_global
-		push!(loggers, global_logger())
-	end
-	DemuxLogger(loggers)
+    if include_current_global
+        push!(loggers, global_logger())
+    end
+    DemuxLogger(loggers)
 end
 
 function handle_message(demux::DemuxLogger, args...; kwargs...)
-	for logger in demux.loggers
+    for logger in demux.loggers
         if comp_handle_message_check(logger, args...; kwargs...)
-			handle_message(logger, args...; kwargs...)
-		end
-	end
+            handle_message(logger, args...; kwargs...)
+        end
+    end
 end
 
 function shouldlog(demux::DemuxLogger, args...)
-	any(comp_shouldlog(logger, args...) for logger in demux.loggers)
+    any(comp_shouldlog(logger, args...) for logger in demux.loggers)
 end
 
 function min_enabled_level(demux::DemuxLogger)
-	minimum(min_enabled_level(logger) for logger in demux.loggers)
+    minimum(min_enabled_level(logger) for logger in demux.loggers)
 end
 
 function catch_exceptions(demux::DemuxLogger)
-	any(catch_exceptions(logger) for logger in demux.loggers)
+    any(catch_exceptions(logger) for logger in demux.loggers)
 end

src/earlyfiltered.jl

@@ -1,5 +1,5 @@
 """
-	EarlyFilteredLogger(filter, logger)
+    EarlyFilteredLogger(filter, logger)
 
 Wraps `logger` in an filter that runs before the log message is created.
 
@@ -16,8 +16,8 @@ As input it will be given a named tuple with the following fields:
 See `?LoggingExtra.shouldlog_args` for more information on what each is.
 """
 struct EarlyFilteredLogger{T <: AbstractLogger, F} <: AbstractLogger
-	filter::F
-	logger::T
+    filter::F
+    logger::T
 end
 
 

src/filelogger.jl

@@ -1,5 +1,5 @@
 struct FileLogger <: AbstractLogger
-	logger::SimpleLogger
+    logger::SimpleLogger
     always_flush::Bool
 end
 
@@ -10,7 +10,7 @@ end
 
 
 function handle_message(filelogger::FileLogger, args...; kwargs...)
-	handle_message(filelogger.logger, args...; kwargs...)
+    handle_message(filelogger.logger, args...; kwargs...)
     filelogger.always_flush && flush(filelogger.logger.stream)
 end
 shouldlog(filelogger::FileLogger, arg...) = true

src/minlevelfiltered.jl

@@ -1,13 +1,13 @@
 """
-	MinLevelLogger(logger, min_enabled_level)
+    MinLevelLogger(logger, min_enabled_level)
 
 Wraps `logger` in an filter that runs before the log message is created.
 In many ways this is just a specialised [`EarlyFilteredLogger`](@ref)
 that only checks the level.
 This filter only allowed messages on or above the `min_enabled_level` to pass.
 """
 struct MinLevelLogger{T <: AbstractLogger, L} <: AbstractLogger
-	logger::T
+    logger::T
     min_level::L
 end
 

src/transformer.jl

@@ -13,20 +13,20 @@ See `?LoggingExtra.handle_message_args` for more information on what each is.
 """
 struct TransformerLogger{T<:AbstractLogger, F} <: AbstractLogger
     transform::F
-	logger::T
+    logger::T
 end
 
 
 function handle_message(transformer::TransformerLogger, args...; kwargs...)
-	log_args = handle_message_args(args...; kwargs...)
+    log_args = handle_message_args(args...; kwargs...)
     new_log_args = transformer.transform(log_args)
-    
+
     args = Tuple(new_log_args)[1:end-1]
     kwargs = new_log_args.kwargs
 
     if comp_handle_message_check(transformer.logger, args...; kwargs...)
-		handle_message(transformer.logger, args...; kwargs...)
-	end
+        handle_message(transformer.logger, args...; kwargs...)
+    end
 end
 
 shouldlog(transformer::TransformerLogger, args...) = true

test/runtests.jl

@@ -17,7 +17,6 @@ using Test: collect_test_logs, TestLogger
     end
     @test length(testlogger_info.logs) == 3
     @test length(testlogger_warn.logs) == 1
-
 end
 
 
@@ -42,7 +41,7 @@ end
     yodawg_filter(logargs) = startswith(logargs.message, "Yo Dawg!")
 
     filtered_logger = ActiveFilteredLogger(yodawg_filter, testlogger)
-    
+
     with_logger(filtered_logger) do
         @info "info1"
         @warn "Yo Dawg! It is a warning"
@@ -58,7 +57,7 @@ end
     filtered_logger = EarlyFilteredLogger(testlogger) do logargs
         logargs.level == Info  # Only exactly Info, nothing more nothing less
     end
-    
+
     with_logger(filtered_logger) do
         @info "info1"
         @warn "Yo Dawg! It is a warning"
@@ -71,7 +70,7 @@ end
 @testset "MinLevel Filter" begin
     testlogger = TestLogger()
     filtered_logger = MinLevelLogger(testlogger, Warn)
-    
+
     with_logger(filtered_logger) do
         @info "info1"
         @warn "Yo Dawg! It is a warning"
@@ -94,7 +93,7 @@ end
             return log_msg
         end
     end
-    
+
     with_logger(transformer_logger) do
         @info "info1"
         @warn "Yo Dawg! It is a warning"
@@ -105,5 +104,3 @@ end
     end
     @test length(testlogger.logs) == 2
 end
-
-