修复了一些bug

zzhoujay · zzhoujay · commit 552d6ee2ea97 · 2016-07-12T00:07:35.000+08:00
diff --git a/app/src/main/java/com/zzhoujay/markdowndemo/MainActivity.java b/app/src/main/java/com/zzhoujay/markdowndemo/MainActivity.java
@@ -46,7 +46,7 @@ protected void onCreate(Bundle savedInstanceState) {
 //        });
 
 
-        final InputStream stream = getResources().openRawResource(R.raw.hello);
+        final InputStream stream = getResources().openRawResource(R.raw.mark);
 //        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(stream));
 //        final StringBuilder sb = new StringBuilder();
 //        String line;
diff --git a/app/src/main/res/raw/mark.md b/app/src/main/res/raw/mark.md
@@ -1,2 +1,12 @@
-* 123
-*
+# hello
+
+> gg
+
+* hello
+* gg
+* zz
+* cc
+
+    hello code
+
+_by zzhoujay_
diff --git a/markdown/src/main/java/com/zzhoujay/markdown/parser/LineQueue.java b/markdown/src/main/java/com/zzhoujay/markdown/parser/LineQueue.java
@@ -9,135 +9,128 @@
 public class LineQueue extends Line {
 
     private List<Line> lines;
-    private int point;
-    private Line currLine;
+    private int position;
     private Stack<Integer> status;
 
     public LineQueue(List<Line> lines) {
         this.lines = lines;
-        point = 0;
-        currLine = get();
+        position = 0;
         status = new Stack<>();
     }
 
     public boolean end() {
-        return point == lines.size() - 1;
+        return position == lines.size() - 1;
     }
 
     public boolean start() {
-        return point == 0;
+        return position == 0;
     }
 
     public Line nextLine() {
         if (!end()) {
-            return lines.get(point + 1);
+            return lines.get(position + 1);
         }
         return null;
     }
 
     public Line prevLine() {
         if (!start()) {
-            return lines.get(point - 1);
+            return lines.get(position - 1);
         }
         return null;
     }
 
     public Line get() {
-        return lines.get(point);
+        return lines.get(position);
     }
 
     public boolean next() {
         if (end()) {
             return false;
         }
-        point++;
-        currLine = get();
+        position++;
         return true;
     }
 
     public boolean prev() {
         if (start()) {
             return false;
         }
-        point--;
-        currLine = get();
+        position--;
         return true;
     }
 
     public void seek(int position) {
-        point = position;
-        currLine = get();
+        this.position = position;
     }
 
     public void push() {
-        status.push(point);
+        status.push(position);
     }
 
     public void pop() {
-        point = status.pop();
-        currLine = get();
+        position = status.pop();
     }
 
     public void add(Line line) {
-        lines.add(point + 1, line);
+        lines.add(position + 1, line);
     }
 
     public Line remove() {
-        return remove(point);
+        return remove(position);
     }
 
     public Line removeNext() {
-        return remove(point + 1);
+        return remove(position + 1);
     }
 
     public Line removePrev() {
-        return remove(point - 1);
+        return remove(position - 1);
     }
 
     public Line remove(int position) {
         Line l = lines.remove(position);
-        currLine = get();
         return l;
     }
 
     @Override
     public CharSequence getBuilder() {
-        return currLine.getBuilder();
+        return get().getBuilder();
     }
 
     @Override
     public void setBuilder(CharSequence builder) {
-        currLine.setBuilder(builder);
+        get().setBuilder(builder);
     }
 
     @Override
     public String getSource() {
-        return currLine.getSource();
+        return get().getSource();
     }
 
     @Override
     public void setSource(String source) {
-        currLine.setSource(source);
+        get().setSource(source);
     }
 
     @Override
     public boolean isCodeBlock() {
-        return currLine.isCodeBlock();
+        return get().isCodeBlock();
     }
 
     @Override
     public void setCodeBlock(boolean codeBlock) {
-        currLine.setCodeBlock(codeBlock);
+        get().setCodeBlock(codeBlock);
     }
 
     @Override
     public int getType() {
-        return currLine.getType();
+        return get().getType();
     }
 
     @Override
     public void setType(int type) {
-        currLine.setType(type);
+        get().setType(type);
     }
 
     @Override
@@ -155,7 +148,4 @@ public int getLineNum() {
         return super.getLineNum();
     }
 
-    public int position() {
-        return point;
-    }
 }
diff --git a/markdown/src/main/java/com/zzhoujay/markdown/parser/MarkDownParser.java b/markdown/src/main/java/com/zzhoujay/markdown/parser/MarkDownParser.java
@@ -7,7 +7,6 @@
 import android.text.TextUtils;
 import android.util.Pair;
 
-import com.zzhoujay.markdown.style.CodeBlockSpan;
 import com.zzhoujay.markdown.style.CodeSpan;
 import com.zzhoujay.markdown.style.ScaleHeightSpan;
 
@@ -132,7 +131,8 @@ private LineQueue collect() throws IOException {
                 lines.add(l);
             }
         }
-        return new LineQueue(lines);
+        LineQueue queue = new LineQueue(lines);
+        return queue;
     }
 
     private int findQuotaCount(Line line) {
@@ -145,12 +145,14 @@ private int findQuotaCount(Line line) {
 
     private Spannable merge(LineQueue queue) {
         boolean block2 = false;
+        removeBlankLine(queue);
         do {
-            Line curr = queue.get();
+
             Line prev = queue.prevLine();
             Line next = queue.nextLine();
+            Line curr = queue.get();
 
-            if (!block2 && tagHandler.codeBlock(curr)) {
+            if (!block2 && tagHandler.codeBlock1(curr)) {
                 removeBlankLine(queue);
                 continue;
             }
@@ -160,7 +162,10 @@ private Spannable merge(LineQueue queue) {
                 queue.remove();
                 if (!block2) {
                     removeBlankLine(queue);
+                } else {
+                    queue.prev();
                 }
+
                 continue;
             }
 
@@ -213,7 +218,6 @@ private Spannable merge(LineQueue queue) {
             }
             curr.setBuilder(SpannableStringBuilder.valueOf(curr.getSource()));
             tagHandler.inline(curr);
-
         } while (queue.next());
         return mergeSpannable(queue);
     }
@@ -223,25 +227,25 @@ private Spannable mergeSpannable(LineQueue queue) {
         SpannableStringBuilder builder = new SpannableStringBuilder();
         List<CharSequence> codeBlock = new ArrayList<>();
         do {
-            Line line = queue.get();
+            Line curr = queue.get();
             Line prev = queue.prevLine();
             Line next = queue.nextLine();
-            switch (line.getType()) {
+            switch (curr.getType()) {
                 case Line.LINE_TYPE_CODE_BLOCK_2:
                     if (prev != null && prev.getType() == Line.LINE_TYPE_CODE_BLOCK_1) {
                         CharSequence[] cs = new CharSequence[codeBlock.size()];
                         builder.append(styleBuilder.codeBlock(codeBlock.toArray(cs))).append('\n').append('\n');
                         codeBlock.clear();
                     }
-                    codeBlock.add(line.getBuilder());
+                    codeBlock.add(curr.getBuilder());
                     continue;
                 case Line.LINE_TYPE_CODE_BLOCK_1:
                     if (prev != null && prev.getType() == Line.LINE_TYPE_CODE_BLOCK_2) {
                         CharSequence[] cs = new CharSequence[codeBlock.size()];
                         builder.append(styleBuilder.codeBlock(codeBlock.toArray(cs))).append('\n').append('\n');
                         codeBlock.clear();
                     }
-                    codeBlock.add(line.getBuilder());
+                    codeBlock.add(curr.getBuilder());
                     continue;
                 default:
                     if (prev != null && (prev.getType() == Line.LINE_TYPE_CODE_BLOCK_1 || prev.getType() == Line.LINE_TYPE_CODE_BLOCK_2)) {
@@ -250,11 +254,11 @@ private Spannable mergeSpannable(LineQueue queue) {
                         codeBlock.clear();
                     }
             }
-            builder.append(line.getBuilder()).append('\n');
-            switch (line.getType()) {
+            builder.append(curr.getBuilder()).append('\n');
+            switch (curr.getType()) {
                 case Line.LINE_TYPE_QUOTA:
                     if (next != null && next.getType() == Line.LINE_TYPE_QUOTA) {
-                        int num = line.getTypeCount();
+                        int num = curr.getTypeCount();
                         SpannableStringBuilder ssb = new SpannableStringBuilder(" ");
                         while (num > 0) {
                             ssb = styleBuilder.quota(ssb);
@@ -430,7 +434,7 @@ private SpannableStringBuilder merge(List<Line> lines) {
                     }
                     codeBlock.add(line.getBuilder());
 //                    if (prev == null || prev.getType() != Line.LINE_TYPE_CODE_BLOCK_2) {
-//                        codeBlock.add(line.getBuilder());
+//                        codeBlock1.add(line.getBuilder());
 //                    }
                     continue;
                 case Line.LINE_TYPE_CODE_BLOCK_1:
@@ -474,14 +478,14 @@ private SpannableStringBuilder merge(List<Line> lines) {
                     break;
 //                case Line.LINE_TYPE_CODE_BLOCK_1:
 //                    if (next == null || next.getType() != Line.LINE_TYPE_CODE_BLOCK_1) {
-//                        builder.append(styleBuilder.codeBlock(" ", CodeBlockSpan.FLAG_END));
+//                        builder.append(styleBuilder.codeBlock1(" ", CodeBlockSpan.FLAG_END));
 //                        builder.append('\n');
 //                        builder.append('\n');
 //                    }
 //                    break;
 //                case Line.LINE_TYPE_CODE_BLOCK_2:
 //                    if (next == null || next.getType() != Line.LINE_TYPE_CODE_BLOCK_2) {
-//                        builder.append(styleBuilder.codeBlock(" ", CodeBlockSpan.FLAG_END));
+//                        builder.append(styleBuilder.codeBlock1(" ", CodeBlockSpan.FLAG_END));
 //                        builder.append('\n');
 //                        builder.append('\n');
 //                    }
@@ -531,7 +535,6 @@ private boolean findCodeBlock(Line line) {
             String content = matcher.group(2);
             line.setType(Line.LINE_TYPE_CODE_BLOCK_1);
             line.setBuilder(content);
-//            line.setCodeBlock(true);
 //            line.setBuilder(styleBuilder.codeBlock(content, CodeBlockSpan.FLAG_CENTER));
             return true;
         }
diff --git a/markdown/src/main/java/com/zzhoujay/markdown/parser/StyleBuilderImpl.java b/markdown/src/main/java/com/zzhoujay/markdown/parser/StyleBuilderImpl.java
@@ -185,7 +185,7 @@ public SpannableStringBuilder codeBlock(CharSequence... charSequence) {
         builder.setSpan(codeBlockSpan, 0, builder.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
         builder.setSpan(sizeSpan, 0, builder.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
         return builder;
-//        return new SpannableStringBuilder(String.format("codeBlock:{%s}", charSequence));
+//        return new SpannableStringBuilder(String.format("codeBlock1:{%s}", charSequence));
     }
 
     @Override
diff --git a/markdown/src/main/java/com/zzhoujay/markdown/parser/TagHandler.java b/markdown/src/main/java/com/zzhoujay/markdown/parser/TagHandler.java
@@ -55,7 +55,7 @@ public interface TagHandler extends TagFinder {
 
     boolean inline(Line line);
 
-    boolean codeBlock(Line line);
+    boolean codeBlock1(Line line);
 
     boolean codeBlock2(Line line);
 
diff --git a/markdown/src/main/java/com/zzhoujay/markdown/parser/TagHandlerImpl.java b/markdown/src/main/java/com/zzhoujay/markdown/parser/TagHandlerImpl.java
@@ -296,7 +296,13 @@ private boolean ol(Line line, boolean normal) {
 
     @Override
     public boolean gap(Line line) {
-        return patternGap.matcher(line.getSource()).find();
+        Matcher matcher = patternGap.matcher(line.getSource());
+        if (matcher.matches()) {
+            line.setType(Line.LINE_TYPE_GAP);
+            line.setBuilder(styleBuilder.gap());
+            return true;
+        }
+        return false;
     }
 
     @Override
@@ -510,7 +516,7 @@ public boolean imageId(String line) {
     }
 
     @Override
-    public boolean codeBlock(Line line) {
+    public boolean codeBlock1(Line line) {
         Matcher matcher = patternCodeBlock.matcher(line.getSource());
         if (matcher.find()) {
             String content = matcher.group(2);

-Original file line number
+Diff line change
@@ @@ -1,2 +1,12 @@ @@
 -* 123
 -*
 +# hello
++
 +> gg
++
 +* hello
 +* gg
 +* zz
 +* cc
++
 +    hello code
++
 +_by zzhoujay_
Original file line number	Diff line number	Diff line change
`@@ -9,135 +9,128 @@`
`9`	`9`	`public class LineQueue extends Line {`
`10`	`10`
`11`	`11`	`private List<Line> lines;`
`12`		`- private int point;`
`13`		`- private Line currLine;`
	`12`	`+ private int position;`
`14`	`13`	`private Stack<Integer> status;`
`15`	`14`
`16`	`15`	`public LineQueue(List<Line> lines) {`
`17`	`16`	`this.lines = lines;`
`18`		`- point = 0;`
`19`		`- currLine = get();`
	`17`	`+ position = 0;`
`20`	`18`	`status = new Stack<>();`
`21`	`19`	`}`
`22`	`20`
`23`	`21`	`public boolean end() {`
`24`		`- return point == lines.size() - 1;`
	`22`	`+ return position == lines.size() - 1;`
`25`	`23`	`}`
`26`	`24`
`27`	`25`	`public boolean start() {`
`28`		`- return point == 0;`
	`26`	`+ return position == 0;`
`29`	`27`	`}`
`30`	`28`
`31`	`29`	`public Line nextLine() {`
`32`	`30`	`if (!end()) {`
`33`		`- return lines.get(point + 1);`
	`31`	`+ return lines.get(position + 1);`
`34`	`32`	`}`
`35`	`33`	`return null;`
`36`	`34`	`}`
`37`	`35`
`38`	`36`	`public Line prevLine() {`
`39`	`37`	`if (!start()) {`
`40`		`- return lines.get(point - 1);`
	`38`	`+ return lines.get(position - 1);`
`41`	`39`	`}`
`42`	`40`	`return null;`
`43`	`41`	`}`
`44`	`42`
`45`	`43`	`public Line get() {`
`46`		`- return lines.get(point);`
	`44`	`+ return lines.get(position);`
`47`	`45`	`}`
`48`	`46`
`49`	`47`	`public boolean next() {`
`50`	`48`	`if (end()) {`
`51`	`49`	`return false;`
`52`	`50`	`}`
`53`		`- point++;`
`54`		`- currLine = get();`
	`51`	`+ position++;`
`55`	`52`	`return true;`
`56`	`53`	`}`
`57`	`54`
`58`	`55`	`public boolean prev() {`
`59`	`56`	`if (start()) {`
`60`	`57`	`return false;`
`61`	`58`	`}`
`62`		`- point--;`
`63`		`- currLine = get();`
	`59`	`+ position--;`
`64`	`60`	`return true;`
`65`	`61`	`}`
`66`	`62`
`67`	`63`	`public void seek(int position) {`
`68`		`- point = position;`
`69`		`- currLine = get();`
	`64`	`+ this.position = position;`
`70`	`65`	`}`
`71`	`66`
`72`	`67`	`public void push() {`
`73`		`- status.push(point);`
	`68`	`+ status.push(position);`
`74`	`69`	`}`
`75`	`70`
`76`	`71`	`public void pop() {`
`77`		`- point = status.pop();`
`78`		`- currLine = get();`
	`72`	`+ position = status.pop();`
`79`	`73`	`}`
`80`	`74`
`81`	`75`	`public void add(Line line) {`
`82`		`- lines.add(point + 1, line);`
	`76`	`+ lines.add(position + 1, line);`
`83`	`77`	`}`
`84`	`78`
`85`	`79`	`public Line remove() {`
`86`		`- return remove(point);`
	`80`	`+ return remove(position);`
`87`	`81`	`}`
`88`	`82`
`89`	`83`	`public Line removeNext() {`
`90`		`- return remove(point + 1);`
	`84`	`+ return remove(position + 1);`
`91`	`85`	`}`
`92`	`86`
`93`	`87`	`public Line removePrev() {`
`94`		`- return remove(point - 1);`
	`88`	`+ return remove(position - 1);`
`95`	`89`	`}`
`96`	`90`
`97`	`91`	`public Line remove(int position) {`
`98`	`92`	`Line l = lines.remove(position);`
`99`		`- currLine = get();`
`100`	`93`	`return l;`
`101`	`94`	`}`
`102`	`95`
`103`	`96`	`@Override`
`104`	`97`	`public CharSequence getBuilder() {`
`105`		`- return currLine.getBuilder();`
	`98`	`+ return get().getBuilder();`
`106`	`99`	`}`
`107`	`100`
`108`	`101`	`@Override`
`109`	`102`	`public void setBuilder(CharSequence builder) {`
`110`		`- currLine.setBuilder(builder);`
	`103`	`+ get().setBuilder(builder);`
`111`	`104`	`}`
`112`	`105`
`113`	`106`	`@Override`
`114`	`107`	`public String getSource() {`
`115`		`- return currLine.getSource();`
	`108`	`+ return get().getSource();`
`116`	`109`	`}`
`117`	`110`
`118`	`111`	`@Override`
`119`	`112`	`public void setSource(String source) {`
`120`		`- currLine.setSource(source);`
	`113`	`+ get().setSource(source);`
`121`	`114`	`}`
`122`	`115`
`123`	`116`	`@Override`
`124`	`117`	`public boolean isCodeBlock() {`
`125`		`- return currLine.isCodeBlock();`
	`118`	`+ return get().isCodeBlock();`
`126`	`119`	`}`
`127`	`120`
`128`	`121`	`@Override`
`129`	`122`	`public void setCodeBlock(boolean codeBlock) {`
`130`		`- currLine.setCodeBlock(codeBlock);`
	`123`	`+ get().setCodeBlock(codeBlock);`
`131`	`124`	`}`
`132`	`125`
`133`	`126`	`@Override`
`134`	`127`	`public int getType() {`
`135`		`- return currLine.getType();`
	`128`	`+ return get().getType();`
`136`	`129`	`}`
`137`	`130`
`138`	`131`	`@Override`
`139`	`132`	`public void setType(int type) {`
`140`		`- currLine.setType(type);`
	`133`	`+ get().setType(type);`
`141`	`134`	`}`
`142`	`135`
`143`	`136`	`@Override`
`@@ -155,7 +148,4 @@ public int getLineNum() {`
`155`	`148`	`return super.getLineNum();`
`156`	`149`	`}`
`157`	`150`
`158`		`- public int position() {`
`159`		`- return point;`
`160`		`- }`
`161`	`151`	`}`
Original file line number	Diff line number	Diff line change
`@@ -185,7 +185,7 @@ public SpannableStringBuilder codeBlock(CharSequence... charSequence) {`
`185`	`185`	`builder.setSpan(codeBlockSpan, 0, builder.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);`
`186`	`186`	`builder.setSpan(sizeSpan, 0, builder.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);`
`187`	`187`	`return builder;`
`188`		`-// return new SpannableStringBuilder(String.format("codeBlock:{%s}", charSequence));`
	`188`	`+// return new SpannableStringBuilder(String.format("codeBlock1:{%s}", charSequence));`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`@Override`