redcar-javamateview 0.2

data/src/com/redcareditor/onig/Range.java

@@ -0,0 +1,45 @@
+package com.redcareditor.onig;
+
+public class Range implements Comparable<Range> {
+	public int start;
+	public int end;
+
+	public Range(int start, int end) {
+		super();
+		this.start = start;
+		this.end = end;
+	}
+
+	@Override
+	public String toString() {
+		if (start == end) {
+			return Integer.toString(start);
+		}
+		return String.format("%d..%d", start, end);
+	}
+
+	public boolean isTouching(Range other) {
+		if (start < other.start) {
+			return other.start <= end + 1;
+		} else {
+			return start <= other.end + 1;
+		}
+	}
+
+	public int compareTo(Range o) {
+		int compareStart = start - o.start;
+		if (compareStart == 0) {
+			return end - o.end;
+		} else {
+			return compareStart;
+		}
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (obj instanceof Range) {
+			return 0 == compareTo((Range) obj);
+		}
+		return false;
+	}
+}

data/src/com/redcareditor/onig/Rx.java

@@ -0,0 +1,167 @@
+package com.redcareditor.onig;
+
+import java.io.UnsupportedEncodingException;
+
+import org.jcodings.Encoding;
+import org.jcodings.specific.UTF8Encoding;
+import org.jcodings.specific.UTF16BEEncoding;
+import org.joni.Matcher;
+import org.joni.Option;
+import org.joni.Regex;
+import org.joni.Region;
+import org.joni.Syntax;
+import org.joni.WarnCallback;
+
+import java.text.CharacterIterator;
+import java.text.StringCharacterIterator;
+
+/**
+ * wrapper class around the Joni Regex library which is a optimized port of
+ * Onigurama
+ * 
+ * @author kungfoo
+ * 
+ */
+public class Rx {
+	public String pattern;
+	public Regex regex;
+	public boolean matchesStartOfLine = false;
+	
+	public static Rx createRx(String pattern){
+//		System.out.printf("createRx(%s)\n", pattern);
+		if(pattern == null){
+			return NullRx.instance();
+		} else {
+			return new Rx(pattern);
+		}
+	}
+
+	/**
+	 * this is used implicitly by the null object class.
+	 */
+	protected Rx(){}
+	
+	private Rx(String pattern) {
+		this.pattern = pattern;
+		regex = compileRegex(pattern);
+		if (!pattern.equals("")) {
+			matchesStartOfLine = pattern.charAt(0) == '^';
+		}
+	}
+
+	public boolean usable() {
+		return (regex != null);
+	}
+
+	public Match search(String target, int start, int end) {
+		byte[] bytes;
+		try {
+			bytes = target.getBytes("UTF-8");
+			Matcher matcher = regex.matcher(bytes, 0, bytes.length);
+			int a = matcher.search(start, end, Option.NONE);
+			
+			if(a == -1){
+				return null;
+			}
+			
+			Region region = matcher.getEagerRegion();
+			return new Match(regex, region, target);
+
+		} catch (UnsupportedEncodingException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+	public Match search(String line) {
+		return search(line, 0, line.length());
+	}
+
+	class Warnings implements WarnCallback {
+		public void warn(String message) {
+			// System.out.printf("got warning from regex: %s\n", message);
+		}
+	}
+
+	private Regex compileRegex(String pattern) {
+		byte[] bytes;
+		try {
+			bytes = pattern.getBytes("UTF-8");
+			return new Regex(bytes, 0, bytes.length, Option.DEFAULT,
+					UTF8Encoding.INSTANCE, Syntax.DEFAULT, new Warnings());
+
+		} catch (UnsupportedEncodingException e) {
+			e.printStackTrace();
+		} catch (org.joni.exception.SyntaxException e) {
+			//System.out.printf("** WARNING: SyntaxException when compiling '%s': %s\n", pattern, e.getMessage());
+			//e.printStackTrace();
+		}
+		return null;
+	}
+	
+	@Override
+	public String toString() {
+		return pattern;
+	}
+	
+    
+	public static String escape(String aRegexFragment){
+		final StringBuilder result = new StringBuilder();
+		
+		final StringCharacterIterator iterator = new StringCharacterIterator(aRegexFragment);
+		char character =  iterator.current();
+		while (character != CharacterIterator.DONE ){
+			if (character == '.') {
+				result.append("\\.");
+			}
+			else if (character == '\\') {
+				result.append("\\\\");
+			}
+			else if (character == '?') {
+				result.append("\\?");
+			}
+			else if (character == '*') {
+				result.append("\\*");
+			}
+			else if (character == '+') {
+				result.append("\\+");
+			}
+			else if (character == '&') {
+				result.append("\\&");
+			}
+			else if (character == ':') {
+				result.append("\\:");
+			}
+			else if (character == '{') {
+				result.append("\\{");
+			}
+			else if (character == '}') {
+				result.append("\\}");
+			}
+			else if (character == '[') {
+				result.append("\\[");
+			}
+			else if (character == ']') {
+				result.append("\\]");
+			}
+			else if (character == '(') {
+				result.append("\\(");
+			}
+			else if (character == ')') {
+				result.append("\\)");
+			}
+			else if (character == '^') {
+				result.append("\\^");
+			}
+			else if (character == '$') {
+				result.append("\\$");
+			}
+			else {
+				result.append(character);
+			}
+			character = iterator.next();
+		}
+		return result.toString();
+	}
+  
+}

data/src/com/redcareditor/plist/Dict.java

@@ -0,0 +1,119 @@
+package com.redcareditor.plist;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.*;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+import org.jdom.Document;
+import org.jdom.Element;
+import org.jdom.JDOMException;
+import org.jdom.input.SAXBuilder;
+
+import com.redcareditor.onig.Rx;
+
+/**
+ * class to load plist files.
+ * 
+ * @author kungfoo
+ * 
+ */
+public class Dict extends PlistNode<Map<String, PlistNode<?>>> {
+
+	private static SAXBuilder builder;
+
+	// NOTE: this method is not thread safe, if we ever go there, this needs to
+	// contain a mutex!
+	private static SAXBuilder getSAXBuilderInstance() {
+		if (builder == null) {
+			builder = new SAXBuilder(false);
+			builder.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
+
+		}
+		return builder;
+	}
+
+	public static Dict parseFile(String filename) {
+		try {
+			Document document = getSAXBuilderInstance().build(new File(filename));
+			return new Dict(document.getRootElement().getChild("dict"));
+
+		} catch (JDOMException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			System.out.println("The file " + filename + " was not found!");
+			e.printStackTrace();
+		}
+		return null;
+	}
+
+	@SuppressWarnings("unchecked")
+	protected Dict(Element element) {
+		value = new HashMap<String, PlistNode<?>>();
+
+		List<Element> children = element.getChildren();
+		String key = null;
+		for (Element c : children) {
+			if (c.getName().equals("key")) {
+				key = c.getValue();
+			} else {
+				value.put(key, PlistNode.parseElement(c));
+			}
+		}
+	}
+
+	public String getString(String key) {
+		return tryGettingValue(this, key);
+	}
+
+	public Integer getInt(String key) {
+		return tryGettingValue(this, key);
+	}
+
+	@SuppressWarnings("unchecked")
+	public String[] getStrings(String key) {
+		List<PlistNode<String>> strings = (List<PlistNode<String>>) value.get(key).value;
+		String[] result = new String[strings.size()];
+		int i = 0;
+		for (PlistNode<String> str : strings) {
+			result[i++] = str.value;
+		}
+		return result;
+	}
+
+	@SuppressWarnings("unchecked")
+	public Dict[] getDictionaries(String key) {
+		List<Dict> dictionaries = (List<Dict>) value.get(key).value;
+		return dictionaries.toArray(new Dict[0]);
+	}
+
+	public List<PlistNode<?>> getArray(String key) {
+		return tryGettingValue(this, key);
+	}
+
+	public Dict getDictionary(String key) {
+		return (Dict) value.get(key);
+	}
+
+	public Rx getRegExp(String key) {
+		return Rx.createRx(getString(key));
+	}
+
+	public boolean containsElement(String key) {
+		return value.containsKey(key);
+	}
+
+	public Set<String> keys() {
+		return value.keySet();
+	}
+
+	@SuppressWarnings("unchecked")
+	private static <T> T tryGettingValue(Dict dict, String key) {
+		if (dict.value.containsKey(key)) {
+			return (T) dict.value.get(key).value;
+		} else {
+			return null;
+		}
+	}
+}

data/src/com/redcareditor/plist/PlistNode.java

@@ -0,0 +1,52 @@
+package com.redcareditor.plist;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.jdom.Element;
+
+/**
+ * generic class that holds the various elements of the property tree in a plist
+ * file.
+ * 
+ * @author kungfoo
+ * 
+ * @param <T>
+ */
+public class PlistNode<T> {
+	public T value;
+
+	public PlistNode(T value) {
+		this.value = value;
+	}
+
+	public PlistNode() {
+	}
+
+	@SuppressWarnings("unchecked")
+	public static PlistNode<?> parseElement(Element element) {
+		if (elementNameIs(element, "string")) {
+			return new PlistNode<String>(element.getValue());
+		}
+		if (elementNameIs(element, "integer")) {
+			return new PlistNode<Integer>(Integer.parseInt(element.getValue()));
+		}
+		if (elementNameIs(element, "array")) {
+			List<PlistNode<?>> array = new ArrayList<PlistNode<?>>();
+			List<Element> children = element.getChildren();
+			for (Element e : children) {
+				array.add(PlistNode.parseElement(e));
+			}
+			return new PlistNode<List<PlistNode<?>>>(array);
+		}
+		if (elementNameIs(element, "dict")) {
+			return new Dict(element);
+		}
+
+		return null;
+	}
+
+	private static boolean elementNameIs(Element element, String name) {
+		return element.getName().equals(name);
+	}
+}

data/src/com/redcareditor/plist/PlistPropertyLoader.java

@@ -0,0 +1,44 @@
+package com.redcareditor.plist;
+
+import java.lang.reflect.Field;
+
+import com.redcareditor.onig.Rx;
+
+/**
+ * This class will load properties from the given {@link Dict} into the object.
+ * It uses reflection, so beware of them typos. :D
+ * 
+ * @author kungfoo
+ */
+public class PlistPropertyLoader {
+	private Dict dict;
+	private Object object;
+
+	public PlistPropertyLoader(Dict dict, Object obj) {
+		this.dict = dict;
+		this.object = obj;
+	}
+
+	public void loadStringProperty(String propertyName) {
+		String value = dict.getString(propertyName);
+		trySettingProperty(propertyName, value);
+	}
+
+	public void loadRegexProperty(String propertyName) {
+		String value = dict.getString(propertyName);
+		Rx regex = Rx.createRx(value);
+		trySettingProperty(propertyName, regex);
+	}
+
+	private void trySettingProperty(String propertyName, Object value) {
+		try {
+			Field prop = object.getClass().getDeclaredField(propertyName);
+			if (value != null) {
+				prop.set(object, value);
+			}
+		} catch (Exception e) {
+			System.out.println(String.format("Can't set %s = %s on object %s", propertyName, value, object.toString()));
+			e.printStackTrace();
+		}
+	}
+}

data/src/com/redcareditor/theme/ScopeSelector.java

@@ -0,0 +1,39 @@
+package com.redcareditor.theme;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.redcareditor.onig.Rx;
+
+public class ScopeSelector {
+	public Rx positiveRegex;
+	public List<Rx> negativeRegexes;
+
+	public static List<ScopeSelector> compile(String scopeSelector) {
+		List<ScopeSelector> result = new ArrayList<ScopeSelector>();
+		for (String selector : scopeSelector.split(",")) {
+			result.add(new ScopeSelector(selector));
+		}
+		return result;
+	}
+
+	private ScopeSelector(String selector) {
+		negativeRegexes = new ArrayList<Rx>();
+		String[] positivesAndNegatives = selector.split(" -");
+		for (String subSelector : positivesAndNegatives) {
+			if (positiveRegex == null) {
+				String s1 = backSlashDots(subSelector);
+				String s2 = s1.replace(" ", ").* .*(");
+				positiveRegex = Rx.createRx("(" + s2 + ")");
+			} else {
+				String s1 = backSlashDots(subSelector);
+				String s2 = s1.replace(" ", ".* .*");
+				negativeRegexes.add(Rx.createRx(s2));
+			}
+		}
+	}
+
+	private String backSlashDots(String subSelector) {
+		return subSelector.trim().replace(".", "\\.");
+	}
+}