redcar-javamateview 0.2

data/test/com/redcareditor/mate/BundleTest.java

@@ -0,0 +1,33 @@
+package com.redcareditor.mate;
+
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class BundleTest {
+
+	@Before
+	public void setUp() {
+		Bundle.loadBundles("input/");
+	}
+
+	@Test
+	public void shouldHaveCreatedCorrectBundles() {
+		String[] bundleNames = new String[] { "Apache", "Ruby", "HTML", "CSS", "JavaScript", "Perl" };
+		for (String bundleName : bundleNames) {
+			containsBundleNamed(bundleName);
+		}
+		assertEquals(11, Bundle.getBundles().size());
+	}
+
+	private void containsBundleNamed(String bundleName) {
+		assertNotNull(Bundle.getBundleByName(bundleName));
+	}
+
+	@Test
+	public void shouldHaveCreatedCorrectGrammars() {
+		assertEquals(1, Bundle.getBundleByName("Apache").getGrammars().size());
+		assertEquals(1, Bundle.getBundleByName("Ruby").getGrammars().size());
+	}
+}

data/test/com/redcareditor/mate/EmptyRangeSetTest.java

@@ -0,0 +1,27 @@
+package com.redcareditor.mate;
+
+import static org.junit.Assert.*;
+
+import org.junit.*;
+
+public class EmptyRangeSetTest {
+	private RangeSet rs;
+
+	@Before
+	public void setUp() throws Exception {
+		rs = new RangeSet();
+	}
+
+	@Test
+	public void testShouldReportEmpty() {
+		assertTrue(rs.isEmpty());
+	}
+
+	@Test
+	public void testShouldAddARange() {
+		rs.add(1, 3);
+		assertEquals(1, rs.length());
+		assertEquals(3, rs.rangeSize());
+	}
+}
+

data/test/com/redcareditor/mate/FilledRangeSetTest.java

@@ -0,0 +1,82 @@
+package com.redcareditor.mate;
+
+import static org.junit.Assert.*;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.redcareditor.onig.Range;
+
+
+public class FilledRangeSetTest {
+	private RangeSet rs;
+
+	@Before
+	public void setUp() throws Exception {
+		rs = new RangeSet();
+		rs.add(1, 3);
+		rs.add(5, 5);
+		rs.add(10, 15);
+	}
+
+	@Test
+	public void testShouldReportLength() {
+		assertEquals(3, rs.length());
+	}
+
+	@Test
+	public void testShouldReportSize() {
+		assertEquals(10, rs.rangeSize());
+	}
+
+	@Test
+	public void testShouldMergeRanges() {
+		rs.add(14, 16);
+		assertEquals(rs.length(), 3);
+		assertEquals(rs.get(0), new Range(1,3));
+		assertEquals(rs.get(1), new Range(5,5));
+		assertEquals(rs.get(2), new Range(10,16));
+	}
+
+	@Test
+	public void testShouldMergeRanges2() {
+		rs.add(7, 11);
+		assertEquals(rs.length(), 3);
+		assertEquals(rs.get(0), new Range(1,3));
+		assertEquals(rs.get(1), new Range(5,5));
+		assertEquals(rs.get(2), new Range(7,15));
+	}
+
+	@Test
+	public void testShouldMergeTwoRanges() {
+		rs.add(4, 11);
+		assertEquals(rs.length(), 1);
+		assertEquals(rs.get(0), new Range(1,15));
+	}
+
+	@Test
+	public void testShouldMergeAllRanges() {
+		rs.add(1, 20);
+		assertEquals(rs.length(), 1);
+		assertEquals(rs.get(0), new Range(1,20));
+	}
+
+	@Test
+	public void testShouldMergeAdjacentRanges() {
+		rs.add(16, 18);
+		assertEquals(rs.length(), 3);
+		assertEquals(rs.get(0), new Range(1,3));
+		assertEquals(rs.get(1), new Range(5,5));
+		assertEquals(rs.get(2), new Range(10,18));
+	}
+
+	@Test
+	public void testShouldMergeTwoAdjacentRanges() {
+		rs.add(4, 4);
+		assertEquals(rs.length(), 2);
+		assertEquals(rs.get(0), new Range(1,5));
+		assertEquals(rs.get(1), new Range(10,15));
+	}
+}
+
+

data/test/com/redcareditor/mate/GrammarTest.java

@@ -0,0 +1,158 @@
+package com.redcareditor.mate;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class GrammarTest {
+	private Grammar g;
+
+	@Before
+	public void setUp() {
+		g = new Grammar("input/Bundles/Apache.tmbundle/Syntaxes/Apache.plist");
+		g.initForUse();
+	}
+
+	@Test
+	public void shouldLoadGrammarInformation() {
+		assertEquals("Apache", g.name);
+		assertEquals("source.apache-config", g.scopeName);
+	}
+
+	@Test
+	public void shouldLoadJavaScriptInformation() {
+		Grammar jg = new Grammar("input/Bundles/JavaScript.tmbundle/Syntaxes/JavaScript.plist");
+		jg.initForUse();
+		assertEquals("JavaScript", jg.name);
+//		assertEquals("source.apache-config", g.scopeName);
+	}
+	
+	@Test
+	public void shouldLoadPatternsIntoMemory() {
+		assertTrue("allPatterns is not empty", g.allPatterns.size() > 0);
+		List<String> patternNames = patternNames(g.allPatterns);
+		assertTrue(patternNames.contains("comment.line.number-sign.apache-config"));
+		assertTrue(patternNames.contains("source.include.apache-config"));
+		assertTrue(patternNames.contains("support.constant.apache-config"));
+	}
+
+  @Test
+  public void shouldLoadPatternsWithoutNames() {
+    Pattern foundPattern = find(g.allPatterns, new Predicate() {
+      public boolean match(Pattern p) {
+        return (p instanceof DoublePattern) &&
+               ((DoublePattern)p).bothCaptures != null &&
+               ((DoublePattern)p).bothCaptures.values().contains("support.constant.rewritecond.apache-config");
+      }
+    });
+    assertNotNull("Unable to find unnamed rewrite pattern", foundPattern);
+  }
+
+  public void assertNotIncludePattern(Pattern p) {
+    assertFalse(p instanceof IncludePattern);
+  }
+
+  @Test
+  public void shouldReplaceAllIncludePatterns() {
+    for (Pattern p : g.allPatterns) {
+      assertNotIncludePattern(p);
+      if (p instanceof DoublePattern) {
+        for (Pattern p1 : ((DoublePattern)p).patterns) {
+          assertNotIncludePattern(p1);
+          if (p1 instanceof DoublePattern) {
+            for (Pattern p2 : ((DoublePattern)p1).patterns)
+            assertNotIncludePattern(p2);
+          }
+        }
+      }
+    }
+  }
+
+  @Test
+  public void shouldReplacePatternBaseProperly() {
+    Pattern p = find(g.allPatterns, new Predicate() {
+      public boolean match(Pattern p) {
+        return "meta.vhost.apache-config".equals(p.name);
+      }
+    });
+    if (p instanceof DoublePattern) {
+      List<String> patternNames = patternNames(((DoublePattern)p).patterns);
+      assertTrue(patternNames.contains("meta.vhost.apache-config"));
+    } else {
+      fail("Expected \"meta.vhost.apache-config\" to parse as a DoublePattern.");
+    }
+  }
+
+  @Test
+  public void shouldReplaceVarsProperly() {
+    Pattern pt = find(g.allPatterns, new Predicate() {
+      public boolean match(Pattern p) {
+        return (p instanceof DoublePattern) &&
+               ((DoublePattern)p).bothCaptures != null &&
+               ((DoublePattern)p).bothCaptures.values().contains("support.constant.rewritecond.apache-config");
+      }
+    });
+    List<String> names = patternNames(((DoublePattern)((DoublePattern)pt).patterns.get(0)).patterns);
+    assertTrue(names.contains("support.variable.apache-config"));
+    assertTrue(names.contains("invalid.illegal.bad-var.apache-config"));
+  }
+
+	@Test
+	public void shouldLoadCaptures() {
+		for (Pattern p : g.allPatterns) {
+			if ("comment.line.number-sign.apache-config".equals(p.name)) {
+				assertEquals("punctuation.definition.comment.apache-config", ((SinglePattern) p).captures.get(1));
+			}
+		}
+	}
+
+  @Test
+  public void shouldMarkDisabledPatternsAsDisabled() {
+    Bundle.loadBundles("input/");
+    Bundle htmlBundle = Bundle.getBundleByName("HTML");
+
+    Grammar html = null;
+    for (Grammar g : htmlBundle.getGrammars()) {
+      if ("HTML".equals(g.name)) {
+        html = g; break;
+      }
+    }
+
+    if (html != null) {
+      html.initForUse();
+      Pattern smarty = find(html.allPatterns, new Predicate() {
+        public boolean match(Pattern p) {
+          return "source.smarty.embedded.html".equals(p.name);
+        }
+      });
+      assertTrue(smarty.disabled);
+    } else {
+      fail("Unable to find HTML grammar in HTML bundle.");
+    }
+  }
+
+  public ArrayList<String> patternNames(List<Pattern> patterns) {
+    ArrayList<String> result = new ArrayList<String>();
+    for (Pattern p : patterns) {
+      result.add(p.name);
+    }
+    return result;
+  }
+
+  public Pattern find(List<Pattern> patterns, Predicate pred) {
+    for (Pattern p : patterns) {
+      if (pred.match(p)) {
+        return p;
+      }
+    }
+    return null;
+  }
+
+  interface Predicate {
+    public boolean match(Pattern p);
+  }
+}

data/test/com/redcareditor/mate/MateTextTest.java

@@ -0,0 +1,35 @@
+package com.redcareditor.mate;
+
+import org.eclipse.swt.widgets.Shell;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class MateTextTest {
+	private MateText mt;
+	
+	@Before
+	public void setUp() {
+		Bundle.loadBundles("input/");
+		Shell shell = new Shell();
+		mt = new MateText(shell);
+	}
+	
+	@Test
+	public void shouldSetTheGrammarByName() {
+		assertTrue(mt.setGrammarByName("Ruby"));
+		assertEquals("Ruby", mt.parser.grammar.name);
+	}
+	
+	@Test
+	public void shouldSetTheGrammarByFilename() {
+		assertEquals("Ruby", mt.setGrammarByFilename("foo.rb"));
+		assertEquals("Apache", mt.setGrammarByFilename(".htaccess"));
+		assertEquals("Ruby", mt.setGrammarByFilename("Rakefile"));
+	}
+	
+	@Test
+	public void shouldSetTheGrammarByFirstLine() {
+		assertEquals("Ruby", mt.setGrammarByFirstLine("#!/usr/bin/ruby\n"));
+	}
+}

data/test/com/redcareditor/mate/ScopeMatcherMatchingTest.java

@@ -0,0 +1,55 @@
+
+package com.redcareditor.mate;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+
+public class ScopeMatcherMatchingTest {
+	public boolean testMatch(String a, String b) {
+		return ScopeMatcher.testMatch(a, b);
+	}
+	
+	@Test
+	public void shouldMatchSimpleWords() {
+		assertTrue(testMatch("comment", "ruby.comment"));
+		assertFalse(testMatch("string", "ruby.comment"));
+		assertTrue(testMatch("source.ruby", "source.ruby comment"));
+	}
+	
+	@Test
+	public void shouldNotMatchSubstrings() {
+		assertFalse(testMatch("source.c", "source.coffee"));
+	}
+	
+	@Test
+	public void shouldTransformDots() {
+		assertFalse(testMatch("source.ruby", "sourcearuby comment"));
+		assertTrue(testMatch("source.ruby", "source.ruby comment"));
+	}
+	
+	@Test
+	public void shouldMatchAtSeparateLocationsInTheString() {
+		assertTrue(testMatch("ruby string", "ruby interpolated string.quoted"));
+	}
+
+	@Test
+	public void shouldMatchWithSelectorOrs() {
+		assertTrue(testMatch("string, comment", "ruby.string"));
+		assertTrue(testMatch("string, comment", "ruby.comment"));
+	}
+
+	@Test
+	public void shouldDealWithNegativeMatches() {
+		assertTrue(testMatch("string - string.double", "ruby.string"));
+		assertFalse(testMatch("string - string.double", "ruby.string.double"));
+	}
+
+	@Test
+	public void shouldDealWithMultipleNegativeMatches() {
+		assertFalse(testMatch("string - string.double - comment", "ruby.string.double"));
+		assertFalse(testMatch("string - string.double - comment", "ruby.string.comment"));
+	}
+}
+
+
+

data/test/com/redcareditor/mate/ScopeMatcherRankingTest.java

@@ -0,0 +1,40 @@
+
+package com.redcareditor.mate;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class ScopeMatcherRankingTest {
+	public String testRank(String a, String b, String scope) {
+		return ScopeMatcher.testRank(a, b, scope);
+	}
+
+	@Test
+	public void shouldRankTwoMatchesByTheirElementDepth() {
+		assertEquals("string", testRank("string", "ruby", "ruby string"));
+	}
+
+	@Test
+	public void shouldRankTwoMatchesByElementDepthNotStringDepth() {
+		assertEquals("string == quoted", testRank("string", "quoted", "string.quoted"));
+	}
+		
+	@Test
+	public void shouldRankTwoMatchesByTheLengthOfTheMatch() {
+		assertEquals("string.quoted", testRank("string.quoted", "string", "string.quoted"));
+	}
+	
+	@Test
+	public void shouldMoveUpTheElementMatchesInCaseOfATieAndCheckElementDepth() {
+		assertEquals("ruby string", testRank("ruby string", "source string", "source ruby string"));
+		assertEquals("ruby string", testRank("source string", "ruby string", "source ruby string"));
+	}
+	
+	@Test
+	public void shouldMoveUpTheElementMatchesInCaseOfATieAndCheckMatchLength() {
+		assertEquals("source.ruby string", testRank("ruby string", "source.ruby string", "source.ruby string"));
+	}
+	
+
+}

data/test/com/redcareditor/onig/RxTest.java

@@ -0,0 +1,54 @@
+package com.redcareditor.onig;
+
+import java.io.BufferedReader;
+import java.io.StringReader;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+import com.redcareditor.util.FileUtility;
+
+public class RxTest {
+	@Test
+	public void testSingleFoo() {
+		String pattern = "^\\s*(class)\\s+(([.a-zA-Z0-9_:]+(\\s*(<)\\s*[.a-zA-Z0-9_:]+)?)|((<<)\\s*[.a-zA-Z0-9_:]+))+";
+		String fileContents = "";
+		try {
+			fileContents = new String(FileUtility.readFully("input/autocompleter.rb"));
+
+			BufferedReader reader = new BufferedReader(new StringReader(fileContents));
+
+			Rx regex = Rx.createRx(pattern);
+
+			String line;
+			while ((line = reader.readLine()) != null) {
+				Match m = regex.search(line, 0, line.length());
+
+				if (m != null) {
+					System.out.println(line);
+					for (Range r : m) {
+						System.out.println(r);
+					}
+				}
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void testNullObject() {
+		String pattern = null;
+		Rx rx = Rx.createRx(pattern);
+		assertTrue(rx instanceof Rx);
+		assertTrue(rx instanceof NullRx);
+		
+		Match match = rx.search("baz");
+		assertTrue(match instanceof NullMatch);
+		// now check that the object behaves in a reasonable way.
+		
+		assertEquals(0, match.numCaptures());
+		assertFalse(match.iterator().hasNext());
+		assertEquals(0, match.ranges().size());
+	}
+}