Mercurial > hg4j
annotate src/org/tmatesoft/hg/internal/NewlineFilter.java @ 643:a8ce405da1f5
v1.2 line of dev: update versions, use patch merge code by default
author | Artem Tikhomirov <tikhomirov.artem@gmail.com> |
---|---|
date | Wed, 19 Jun 2013 16:03:11 +0200 |
parents | 6526d8adbc0f |
children |
rev | line source |
---|---|
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
1 /* |
628
6526d8adbc0f
Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
2 * Copyright (c) 2011-2013 TMate Software Ltd |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
3 * |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
4 * This program is free software; you can redistribute it and/or modify |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
5 * it under the terms of the GNU General Public License as published by |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
6 * the Free Software Foundation; version 2 of the License. |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
7 * |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
8 * This program is distributed in the hope that it will be useful, |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
11 * GNU General Public License for more details. |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
12 * |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
13 * For information on how to redistribute this software under |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
14 * the terms of a license other than GNU General Public License |
130
7567f4a42fe5
Correct contact address
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
118
diff
changeset
|
15 * contact TMate Software at support@hg4j.com |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
16 */ |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
17 package org.tmatesoft.hg.internal; |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
18 |
355
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
19 import static java.lang.Math.max; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
20 import static java.lang.Math.min; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
21 import static org.tmatesoft.hg.internal.Filter.Direction.FromRepo; |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
22 import static org.tmatesoft.hg.internal.Filter.Direction.ToRepo; |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
23 import static org.tmatesoft.hg.internal.KeywordFilter.copySlice; |
456
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
423
diff
changeset
|
24 import static org.tmatesoft.hg.util.LogFacility.Severity.Warn; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
25 |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
26 import java.io.File; |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
27 import java.nio.ByteBuffer; |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
28 import java.util.ArrayList; |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
29 import java.util.Map; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
30 |
628
6526d8adbc0f
Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
31 import org.tmatesoft.hg.core.HgIOException; |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
356
diff
changeset
|
32 import org.tmatesoft.hg.repo.HgInvalidStateException; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
33 import org.tmatesoft.hg.repo.HgRepository; |
356
91d75e1bac9f
Consistent approach to deal with adaptable objects. Give adaptable precedence over instanceof to allow conditional response when classes do implement desired interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
355
diff
changeset
|
34 import org.tmatesoft.hg.util.Adaptable; |
133
4a948ec83980
core.Path to util.Path as it's not Hg repo dependant
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
130
diff
changeset
|
35 import org.tmatesoft.hg.util.Path; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
36 |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
37 /** |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
38 * |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
39 * @author Artem Tikhomirov |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
40 * @author TMate Software Ltd. |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
41 */ |
356
91d75e1bac9f
Consistent approach to deal with adaptable objects. Give adaptable precedence over instanceof to allow conditional response when classes do implement desired interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
355
diff
changeset
|
42 public class NewlineFilter implements Filter, Preview, Adaptable { |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
43 |
355
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
44 // if processInconsistent is false, filter simply pass incorrect newline characters (single \r or \r\n on *nix and single \n on Windows) as is, |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
45 // i.e. doesn't try to convert them into appropriate newline characters. |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
46 // XXX revisit if Keyword extension behaves differently - WTF??? |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
47 private final boolean processInconsistent; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
48 private final boolean winToNix; |
355
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
49 |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
50 // NOTE, if processInconsistent == true, foundCRLF and foundLoneLF are not initialized |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
51 private boolean foundLoneLF = false; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
52 private boolean foundCRLF = false; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
53 |
355
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
54 // next two factory methods for test purposes |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
55 public static NewlineFilter createWin2Nix(boolean processMixed) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
56 return new NewlineFilter(!processMixed, 0); |
352
7b34d24b8f4d
Tests for newline filter (eol extension) functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
57 } |
7b34d24b8f4d
Tests for newline filter (eol extension) functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
58 |
355
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
59 public static NewlineFilter createNix2Win(boolean processMixed) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
60 return new NewlineFilter(!processMixed, 1); |
352
7b34d24b8f4d
Tests for newline filter (eol extension) functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
61 } |
7b34d24b8f4d
Tests for newline filter (eol extension) functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
62 |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
63 private NewlineFilter(boolean onlyConsistent, int transform) { |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
64 winToNix = transform == 0; |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
65 processInconsistent = !onlyConsistent; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
66 } |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
67 |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
68 public ByteBuffer filter(ByteBuffer src) { |
356
91d75e1bac9f
Consistent approach to deal with adaptable objects. Give adaptable precedence over instanceof to allow conditional response when classes do implement desired interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
355
diff
changeset
|
69 if (!processInconsistent && !previewDone) { |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
356
diff
changeset
|
70 throw new HgInvalidStateException("This filter requires preview operation prior to actual filtering when eol.only-consistent is true"); |
355
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
71 } |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
72 if (!processInconsistent && foundLoneLF && foundCRLF) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
73 // do not process inconsistent newlines |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
74 return src; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
75 } |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
76 if (winToNix) { |
355
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
77 if (!processInconsistent && !foundCRLF) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
78 // no reason to process if no CRLF in the data stream |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
79 return src; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
80 } |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
81 return win2nix(src); |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
82 } else { |
355
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
83 if (!processInconsistent && !foundLoneLF) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
84 return src; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
85 } |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
86 return nix2win(src); |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
87 } |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
88 } |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
89 |
356
91d75e1bac9f
Consistent approach to deal with adaptable objects. Give adaptable precedence over instanceof to allow conditional response when classes do implement desired interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
355
diff
changeset
|
90 public <T> T getAdapter(Class<T> adapterClass) { |
91d75e1bac9f
Consistent approach to deal with adaptable objects. Give adaptable precedence over instanceof to allow conditional response when classes do implement desired interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
355
diff
changeset
|
91 // conditionally through getAdapter |
91d75e1bac9f
Consistent approach to deal with adaptable objects. Give adaptable precedence over instanceof to allow conditional response when classes do implement desired interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
355
diff
changeset
|
92 if (Preview.class == adapterClass) { |
91d75e1bac9f
Consistent approach to deal with adaptable objects. Give adaptable precedence over instanceof to allow conditional response when classes do implement desired interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
355
diff
changeset
|
93 // when processInconsistent is false, we need to preview data stream to ensure line terminators are consistent. |
91d75e1bac9f
Consistent approach to deal with adaptable objects. Give adaptable precedence over instanceof to allow conditional response when classes do implement desired interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
355
diff
changeset
|
94 // otherwise, no need to look into the stream |
91d75e1bac9f
Consistent approach to deal with adaptable objects. Give adaptable precedence over instanceof to allow conditional response when classes do implement desired interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
355
diff
changeset
|
95 if (!processInconsistent) { |
91d75e1bac9f
Consistent approach to deal with adaptable objects. Give adaptable precedence over instanceof to allow conditional response when classes do implement desired interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
355
diff
changeset
|
96 return adapterClass.cast(this); |
91d75e1bac9f
Consistent approach to deal with adaptable objects. Give adaptable precedence over instanceof to allow conditional response when classes do implement desired interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
355
diff
changeset
|
97 } |
91d75e1bac9f
Consistent approach to deal with adaptable objects. Give adaptable precedence over instanceof to allow conditional response when classes do implement desired interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
355
diff
changeset
|
98 } |
91d75e1bac9f
Consistent approach to deal with adaptable objects. Give adaptable precedence over instanceof to allow conditional response when classes do implement desired interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
355
diff
changeset
|
99 return null; |
91d75e1bac9f
Consistent approach to deal with adaptable objects. Give adaptable precedence over instanceof to allow conditional response when classes do implement desired interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
355
diff
changeset
|
100 } |
91d75e1bac9f
Consistent approach to deal with adaptable objects. Give adaptable precedence over instanceof to allow conditional response when classes do implement desired interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
355
diff
changeset
|
101 |
355
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
102 private boolean prevBufLastByteWasCR = false; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
103 private boolean previewDone = false; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
104 |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
105 public void preview(ByteBuffer src) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
106 previewDone = true; // guard |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
107 if (processInconsistent) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
108 // gonna handle them anyway, no need to check. TODO Do not implement Preview directly, but rather |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
109 return; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
110 } |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
111 if (foundLoneLF && foundCRLF) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
112 // already know it's inconsistent |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
113 return; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
114 } |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
115 final byte CR = (byte) '\r'; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
116 final byte LF = (byte) '\n'; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
117 int x = src.position(); |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
118 while (x < src.limit()) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
119 int in = indexOf(LF, src, x); |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
120 if (in == -1) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
121 // no line feed, but what if it's CRLF broken in the middle? |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
122 prevBufLastByteWasCR = CR == src.get(src.limit() - 1); |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
123 return; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
124 } |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
125 if (in == 0) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
126 if (prevBufLastByteWasCR) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
127 foundCRLF = true; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
128 } else { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
129 foundLoneLF = true; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
130 } |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
131 } else { // in > 0 && in >= x |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
132 if (src.get(in - 1) == CR) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
133 foundCRLF = true; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
134 } else { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
135 foundLoneLF = true; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
136 } |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
137 } |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
138 if (foundCRLF && foundLoneLF) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
139 return; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
140 } |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
141 x = in + 1; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
142 } |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
143 } |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
144 |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
145 private ByteBuffer win2nix(ByteBuffer src) { |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
146 int lookupStart = src.position(); // source index |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
147 ByteBuffer dst = null; |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
148 final byte CR = (byte) '\r'; |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
149 final byte LF = (byte) '\n'; |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
150 while (lookupStart < src.limit()) { |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
151 // x, lookupStart, ir and in are absolute positions within src buffer, which is never read with modifying operations |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
152 int ir = indexOf(CR, src, lookupStart); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
153 int in = indexOf(LF, src, lookupStart); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
154 if (in != -1) { |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
155 if (ir == -1 || ir > in) { |
355
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
156 // lone LF. CR, if present, goes after LF, process up to that lone, closest LF; let next iteration decide what to do with CR@ir |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
157 if (!processInconsistent && foundCRLF) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
158 assert foundLoneLF == true : "preview() shall initialize this"; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
159 fail(src, in); |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
160 } |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
161 dst = consume(src, lookupStart, in+1, dst); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
162 lookupStart = in + 1; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
163 } else { |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
164 // ir < in |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
165 if (onlyCRup2limit(src, ir, in)) { |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
166 // CR...CRLF; |
355
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
167 if (!processInconsistent && foundLoneLF) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
168 assert foundCRLF == true : "preview() shall initialize this"; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
169 fail(src, ir); |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
170 } |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
171 dst = consume(src, lookupStart, ir, dst); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
172 dst.put(LF); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
173 lookupStart = in+1; |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
174 } else { |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
175 // CR...CR...^CR....LF |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
176 dst = consume(src, lookupStart, ir+1, dst); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
177 // although can search for ^CR, here I copy CR one by one as I don't expect huge sequences of CR to optimize for |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
178 lookupStart = ir+1; |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
179 } |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
180 } |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
181 } else { |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
182 // no newlines |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
183 if (ir != -1 && onlyCRup2limit(src, ir, src.limit())) { |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
184 // \r as last character(s) is the only case we care about when there're no LF found |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
185 // cases like \r\r\r<EOB>\n shall be handled like \r\n, hence onlyCRup2limit |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
186 dst = consume(src, lookupStart, ir, dst); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
187 lookupStart = src.limit() - 1; // leave only last CR for next buffer |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
188 } else { |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
189 // consume all. don't create a copy of src if there's no dst yet |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
190 if (dst != null) { |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
191 copySlice(src, lookupStart, src.limit(), dst); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
192 lookupStart = src.limit(); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
193 } |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
194 } |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
195 break; |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
196 } |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
197 } |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
198 src.position(lookupStart); // mark we've consumed up to x |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
199 return dst == null ? src : (ByteBuffer) dst.flip(); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
200 } |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
201 |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
202 // true if [from..limit) are CR |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
203 private static boolean onlyCRup2limit(ByteBuffer src, int from, int limit) { |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
204 // extended version of (ir+1 == src.limit()): check all in [ir..src.limit) are CR |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
205 for (int i = from; i < limit; i++) { |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
206 if (src.get(i) != '\r') { |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
207 return false; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
208 } |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
209 } |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
210 return true; |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
211 } |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
212 private static ByteBuffer consume(ByteBuffer src, int from, int to, ByteBuffer dst) { |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
213 if (dst == null) { |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
214 dst = ByteBuffer.allocate(src.remaining()); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
215 } |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
216 copySlice(src, from, to, dst); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
217 return dst; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
218 } |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
219 |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
220 private ByteBuffer nix2win(ByteBuffer src) { |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
221 int x = src.position(); |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
222 ByteBuffer dst = null; |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
223 final byte CR = (byte) '\r'; |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
224 final byte LF = (byte) '\n'; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
225 while (x < src.limit()) { |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
226 int in = indexOf(LF, src, x); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
227 if (in != -1) { |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
228 if (in > x && src.get(in - 1) == CR) { |
355
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
229 // found CRLF |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
230 if (!processInconsistent && foundLoneLF) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
231 assert foundCRLF == true : "preview() shall initialize this"; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
232 fail(src, in-1); |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
233 } |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
234 if (dst == null) { |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
235 dst = ByteBuffer.allocate(src.remaining() * 2); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
236 } |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
237 copySlice(src, x, in+1, dst); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
238 x = in + 1; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
239 } else { |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
240 // found stand-alone LF, need to output CRLF |
355
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
241 if (!processInconsistent && foundCRLF) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
242 assert foundLoneLF == true : "preview() shall initialize this"; |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
243 fail(src, in); |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
244 } |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
245 if (dst == null) { |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
246 dst = ByteBuffer.allocate(src.remaining() * 2); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
247 } |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
248 copySlice(src, x, in, dst); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
249 dst.put(CR); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
250 dst.put(LF); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
251 x = in + 1; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
252 } |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
253 } else { |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
254 // no newlines (no LF), just copy what left |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
255 if (dst != null) { |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
256 copySlice(src, x, src.limit(), dst); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
257 x = src.limit(); |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
258 } |
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
259 break; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
260 } |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
261 } |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
262 src.position(x); |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
263 return dst == null ? src : (ByteBuffer) dst.flip(); |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
264 } |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
265 |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
266 |
355
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
267 // Test: nlFilter.fail(ByteBuffer.wrap(new "test string".getBytes()), 5); |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
268 private void fail(ByteBuffer b, int pos) { |
355
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
269 StringBuilder sb = new StringBuilder(); |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
270 for (int i = max(pos-10, 0), x = min(pos + 10, b.limit()); i < x; i++) { |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
271 sb.append(String.format("%02x ", b.get(i))); |
f2c11fe7f3e9
Newline filter shall respect whole stream when deciding whether to process line terminators, hence added stream preview functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
353
diff
changeset
|
272 } |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
356
diff
changeset
|
273 // TODO post-1.0 need HgBadDataException (not InvalidState but smth closer to data stream error) |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
356
diff
changeset
|
274 // but don't want to add class for the single use now |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
356
diff
changeset
|
275 throw new HgInvalidStateException(String.format("Inconsistent newline characters in the stream %s (char 0x%x, local index:%d)", sb.toString(), b.get(pos), pos)); |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
276 } |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
277 |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
278 private static int indexOf(byte ch, ByteBuffer b, int from) { |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
279 return indexOf(ch, b, from, b.limit()); |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
280 } |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
281 |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
282 // looks up in buf[from..to) |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
283 private static int indexOf(byte ch, ByteBuffer b, int from, int to) { |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
284 for (int i = from; i < to; i++) { |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
285 byte c = b.get(i); |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
286 if (ch == c) { |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
287 return i; |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
288 } |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
289 } |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
290 return -1; |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
291 } |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
292 |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
293 public static class Factory implements Filter.Factory { |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
294 private boolean processOnlyConsistent = true; |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
295 private Path.Matcher lfMatcher; |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
296 private Path.Matcher crlfMatcher; |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
297 private Path.Matcher binMatcher; |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
298 private Path.Matcher nativeMatcher; |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
299 private String nativeRepoFormat; |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
300 private String nativeOSFormat; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
301 |
331
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
295
diff
changeset
|
302 public void initialize(HgRepository hgRepo) { |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
303 processOnlyConsistent = hgRepo.getConfiguration().getBooleanValue("eol", "only-consistent", true); |
237
6e1373b54e9b
Allow access to working copy content through HgDataFile. Give access to repository's working dir
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
304 File cfgFile = new File(hgRepo.getWorkingDir(), ".hgeol"); |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
305 if (!cfgFile.canRead()) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
306 return; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
307 } |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
308 // XXX if .hgeol is not checked out, we may get it from repository |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
309 // HgDataFile cfgFileNode = hgRepo.getFileNode(".hgeol"); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
310 // if (!cfgFileNode.exists()) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
311 // return; |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
312 // } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
313 // XXX perhaps, add HgDataFile.hasWorkingCopy and workingCopyContent()? |
490
b3c16d1aede0
Refactoring: move HgRepository's implementation aspects to Internals (which is now its imlementation counterpart and primary repository class to be used by other parts of the library)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
314 ConfigFile hgeol = new ConfigFile(hgRepo.getSessionContext()); |
295
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
315 try { |
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
316 hgeol.addLocation(cfgFile); |
628
6526d8adbc0f
Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
317 } catch (HgIOException ex) { |
490
b3c16d1aede0
Refactoring: move HgRepository's implementation aspects to Internals (which is now its imlementation counterpart and primary repository class to be used by other parts of the library)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
318 hgRepo.getSessionContext().getLog().dump(getClass(), Warn, ex, null); |
295
981f9f50bb6c
Issue 11: Error log facility. SessionContext to share common facilities
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
237
diff
changeset
|
319 } |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
320 nativeRepoFormat = hgeol.getSection("repository").get("native"); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
321 if (nativeRepoFormat == null) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
322 nativeRepoFormat = "LF"; |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
323 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
324 final String os = System.getProperty("os.name"); // XXX need centralized set of properties |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
325 nativeOSFormat = os.indexOf("Windows") != -1 ? "CRLF" : "LF"; |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
326 // I assume pattern ordering in .hgeol is not important |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
327 ArrayList<String> lfPatterns = new ArrayList<String>(); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
328 ArrayList<String> crlfPatterns = new ArrayList<String>(); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
329 ArrayList<String> nativePatterns = new ArrayList<String>(); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
330 ArrayList<String> binPatterns = new ArrayList<String>(); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
331 for (Map.Entry<String,String> e : hgeol.getSection("patterns").entrySet()) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
332 if ("CRLF".equals(e.getValue())) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
333 crlfPatterns.add(e.getKey()); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
334 } else if ("LF".equals(e.getValue())) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
335 lfPatterns.add(e.getKey()); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
336 } else if ("native".equals(e.getValue())) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
337 nativePatterns.add(e.getKey()); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
338 } else if ("BIN".equals(e.getValue())) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
339 binPatterns.add(e.getKey()); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
340 } else { |
490
b3c16d1aede0
Refactoring: move HgRepository's implementation aspects to Internals (which is now its imlementation counterpart and primary repository class to be used by other parts of the library)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
483
diff
changeset
|
341 hgRepo.getSessionContext().getLog().dump(getClass(), Warn, "Can't recognize .hgeol entry: %s for %s", e.getValue(), e.getKey()); |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
342 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
343 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
344 if (!crlfPatterns.isEmpty()) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
345 crlfMatcher = new PathGlobMatcher(crlfPatterns.toArray(new String[crlfPatterns.size()])); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
346 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
347 if (!lfPatterns.isEmpty()) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
348 lfMatcher = new PathGlobMatcher(lfPatterns.toArray(new String[lfPatterns.size()])); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
349 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
350 if (!binPatterns.isEmpty()) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
351 binMatcher = new PathGlobMatcher(binPatterns.toArray(new String[binPatterns.size()])); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
352 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
353 if (!nativePatterns.isEmpty()) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
354 nativeMatcher = new PathGlobMatcher(nativePatterns.toArray(new String[nativePatterns.size()])); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
355 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
356 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
357 |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
358 public Filter create(Path path, Options opts) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
359 if (binMatcher == null && crlfMatcher == null && lfMatcher == null && nativeMatcher == null) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
360 // not initialized - perhaps, no .hgeol found |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
361 return null; |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
362 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
363 if (binMatcher != null && binMatcher.accept(path)) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
364 return null; |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
365 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
366 if (crlfMatcher != null && crlfMatcher.accept(path)) { |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
367 return new NewlineFilter(processOnlyConsistent, 1); |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
368 } else if (lfMatcher != null && lfMatcher.accept(path)) { |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
369 return new NewlineFilter(processOnlyConsistent, 0); |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
370 } else if (nativeMatcher != null && nativeMatcher.accept(path)) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
371 if (nativeOSFormat.equals(nativeRepoFormat)) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
372 return null; |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
373 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
374 if (opts.getDirection() == FromRepo) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
375 int transform = "CRLF".equals(nativeOSFormat) ? 1 : 0; |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
376 return new NewlineFilter(processOnlyConsistent, transform); |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
377 } else if (opts.getDirection() == ToRepo) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
378 int transform = "CRLF".equals(nativeOSFormat) ? 0 : 1; |
353
0f3687e79f5a
Treat content with target line endings as correct regardless eol.only-consistent setting
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
352
diff
changeset
|
379 return new NewlineFilter(processOnlyConsistent, transform); |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
380 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
381 return null; |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
382 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
383 return null; |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
384 } |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
385 } |
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
386 } |