diff options
Diffstat (limited to 'javatoscachecker/kwalify/src')
25 files changed, 4331 insertions, 0 deletions
diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/BaseException.java b/javatoscachecker/kwalify/src/main/java/kwalify/BaseException.java new file mode 100644 index 0000000..c2cc83b --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/BaseException.java @@ -0,0 +1,51 @@ +/* + * @(#)BaseException.java $Rev: 3 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +/** + * base class of ValidationException and SchemaException. + * + * @revision $Rev: 3 $ + * @release $Release: 0.5.1 $ + */ +public abstract class BaseException extends KwalifyRuntimeException implements Comparable { + + String _ypath; + Object _value; + Rule _rule; + String _errorSymbol; + int _linenum = -1; + + public BaseException(String message, String ypath, Object value, Rule rule, String errorSymbol) { + super(message); + _ypath = ypath; + _value = value; + _rule = rule; + _errorSymbol = errorSymbol; + } + + public String getPath() { return _ypath.equals("") ? "/" : _ypath; } + //public void setPath(String ypath) { _ypath = ypath; } + + public Object getValue() { return _value; } + //public void setValue(Object value) { _value = value; } + + public Rule getRule() { return _rule; } + // + //public void setRule(Rule rule) { _rule = rule; } + + public String getErrorSymbol() { return _errorSymbol; } + //public void setErrorSymbol(String errorSymbol) { _errorSymbol = errorSymbol; } + + public int getLineNumber() { return _linenum; } + public void setLineNumber(int linenum) { _linenum = linenum; } + + public int compareTo(Object obj) { + int n = ((ValidationException)obj).getLineNumber(); + return _linenum - n; + } +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/CommandOptionException.java b/javatoscachecker/kwalify/src/main/java/kwalify/CommandOptionException.java new file mode 100644 index 0000000..e35be85 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/CommandOptionException.java @@ -0,0 +1,33 @@ +/* + * @(#)CommandOptionException.java $Rev: 4 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +/** + * exception class thrown if command-line option is wrong + * + * @revision $Rev: 4 $ + * @release $Release: 0.5.1 $ + */ +public class CommandOptionException extends KwalifyException { + private static final long serialVersionUID = 6433387612335104714L; + + private String _error_symbol = null; + private char _option; + + public CommandOptionException(String message, char option, String error_symbol) { + super(message); + _option = option; + _error_symbol = error_symbol; + } + + public String getErrorSymbol() { return _error_symbol; } + public void setErrorSymbol(String error_symbol) { _error_symbol = error_symbol; } + + public char getOption() { return _option; } + public void setOption(char option) { _option = option; } + +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/Defaultable.java b/javatoscachecker/kwalify/src/main/java/kwalify/Defaultable.java new file mode 100644 index 0000000..7e7c692 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/Defaultable.java @@ -0,0 +1,18 @@ +/* + * @(#)Defaultable.java $Rev: 3 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +/** + * interface to have default value + * + * @revision $Rev: 3 $ + * @release $Release: 0.5.1 $ + */ +public interface Defaultable { + public Object getDefault(); + public void setDefault(Object value); +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/DefaultableHashMap.java b/javatoscachecker/kwalify/src/main/java/kwalify/DefaultableHashMap.java new file mode 100644 index 0000000..0009205 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/DefaultableHashMap.java @@ -0,0 +1,48 @@ +/* + * @(#)DefaultableHashMap.java $Rev: 4 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +import java.util.Map; +import java.util.HashMap; + +/** + * hash map which can have default value + * + * @revision $Rev: 4 $ + * @release $Release: 0.5.1 $ + */ +public class DefaultableHashMap extends HashMap implements Defaultable { + + private static final long serialVersionUID = -5224819562023897380L; + + private Object _default = null; + + public DefaultableHashMap() { + super(); + } + + public DefaultableHashMap(int initialCapacity) { + super(initialCapacity); + } + + public DefaultableHashMap(int initialCapacity, float loadFactor) { + super(initialCapacity, loadFactor); + } + + public DefaultableHashMap(Map m) { + super(m); + } + + public Object getDefault() { return _default; } + + public void setDefault(Object value) { _default = value; } + + public Object get(Object key) { + return containsKey(key) ? super.get(key) : _default; + } + +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/InvalidPathException.java b/javatoscachecker/kwalify/src/main/java/kwalify/InvalidPathException.java new file mode 100644 index 0000000..94eeca2 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/InvalidPathException.java @@ -0,0 +1,23 @@ +/* + * @(#)InvalidPathException.java $Rev: 4 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +/** + * exception class thrown by YamlParser#setErrorsLineNumber() when path is wrong + * + * @revision $Rev: 4 $ + * @release $Release: 0.5.1 $ + */ +public class InvalidPathException extends KwalifyRuntimeException { + private static final long serialVersionUID = -4601461998104850880L; + + //private int _linenum; + + public InvalidPathException(String message) { + super(message); + } +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/InvalidTypeException.java b/javatoscachecker/kwalify/src/main/java/kwalify/InvalidTypeException.java new file mode 100644 index 0000000..fe60ca0 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/InvalidTypeException.java @@ -0,0 +1,21 @@ +/* + * @(#)InvalidTypeException.java $Rev: 4 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +/** + * exception class thrown by Util.compareValues() when comparing different type values. + * + * @revision $Rev: 4 $ + * @release $Release: 0.5.1 $ + */ +public class InvalidTypeException extends KwalifyRuntimeException { + private static final long serialVersionUID = -6937887618526171845L; + + public InvalidTypeException(String message) { + super(message); + } +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/KwalifyException.java b/javatoscachecker/kwalify/src/main/java/kwalify/KwalifyException.java new file mode 100644 index 0000000..976a263 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/KwalifyException.java @@ -0,0 +1,20 @@ +/* + * @(#)KwalifyException.java $Rev: 3 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +/** + * base exception class of all exception in Kwalify + * + * @revision $Rev: 3 $ + * @release $Release: 0.5.1 $ + * @see KwalifyRuntimeException + */ +public abstract class KwalifyException extends Exception { + public KwalifyException(String message) { + super(message); + } +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/KwalifyRuntimeException.java b/javatoscachecker/kwalify/src/main/java/kwalify/KwalifyRuntimeException.java new file mode 100644 index 0000000..75e4764 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/KwalifyRuntimeException.java @@ -0,0 +1,19 @@ +/* + * @(#)KwalifyRuntimeException.java $Rev: 3 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +/** + * base class of all runtime exception class in Kwalify + * + * @revision $Rev: 3 $ + * @release $Release: 0.5.1 $ + */ +public abstract class KwalifyRuntimeException extends RuntimeException { + public KwalifyRuntimeException(String message) { + super(message); + } +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/Main.java b/javatoscachecker/kwalify/src/main/java/kwalify/Main.java new file mode 100644 index 0000000..d2c39e2 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/Main.java @@ -0,0 +1,305 @@ +/* + * @(#)Main.java $Rev: 4 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +import java.util.List; +import java.util.Map; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Collections; +import java.util.regex.Matcher; +import java.io.IOException; + +/** + * class for main program + * + * @revision $Rev: 4 $ + * @release $Release: 0.5.1 $ + */ +public class Main { + + private String _command; + private boolean _flag_help = false; // print help + private boolean _flag_version = false; // print version + private boolean _flag_silent = false; // suppress messages + private boolean _flag_meta = false; // meta validation + private boolean _flag_untabify = false; // expand tab charactor to spaces + private boolean _flag_emacs = false; // show errors in emacs style + private boolean _flag_linenum = false; // show line number on where errors happened + private boolean _flag_debug = false; // internal use only + private String _schema_filename = null; // schema filename + private Map _properties = new HashMap(); + + + boolean isDebug() { return _flag_debug; } + + + public String inspect() { + StringBuffer sb = new StringBuffer(); + sb.append("command : ").append(_command ).append('\n'); + sb.append("flag_help : ").append(_flag_help ).append('\n'); + sb.append("flag_version : ").append(_flag_version ).append('\n'); + sb.append("flag_silent : ").append(_flag_silent ).append('\n'); + sb.append("flag_meta : ").append(_flag_meta ).append('\n'); + sb.append("flag_untabify : ").append(_flag_untabify ).append('\n'); + sb.append("flag_emacs : ").append(_flag_emacs ).append('\n'); + sb.append("flag_linenum : ").append(_flag_linenum ).append('\n'); + sb.append("flag_debug : ").append(_flag_debug ).append('\n'); + sb.append("schema_filename : ").append(_schema_filename).append('\n'); + sb.append("properties:\n"); + for (Iterator it = _properties.keySet().iterator(); it.hasNext(); ) { + Object key = it.next(); + Object val = _properties.get(key); + sb.append(" ").append(key).append(": ").append(val).append('\n'); + } + return sb.toString(); + } + + + private static final String REVISION = "$Release: 0.5.1 $"; + private static final String HELP = "" + + "Usage1: %s [-hvstlE] -f schema.yaml doc.yaml [doc2.yaml ...]\n" + + "Usage2: %s [-hvstlE] -m schema.yaml [schema2.yaml ...]\n" + + " -h, --help : help\n" + + " -v : version\n" + + " -s : silent\n" + + " -f schema.yaml : schema definition file\n" + + " -m : meta-validation mode\n" + + " -t : expand tab character automatically\n" + + " -l : show linenumber when errored (experimental)\n" + + " -E : show errors in emacs-style (implies '-l')\n" + ; + + + public Main(String command) { + _command = command; + } + + + public String execute(String[] args) throws IOException, CommandOptionException, SyntaxException { + // parse command-line options + String[] filenames = parseOptions(args); + + // help or version + StringBuffer sb = new StringBuffer(); + if (_flag_version) { + sb.append(version()).append('\n'); + } + if (_flag_help) { + sb.append(help()); + } + if (sb.length() > 0) { + return sb.toString(); + } + + // main + String s = null; + if (_flag_meta) { + s = metaValidate(filenames); + } else if (_schema_filename == null) { + throw optionError("command.option.noaction", '\0'); + } else if (_flag_debug) { + s = inspectSchemaFile(_schema_filename); + } else { + s = validate(filenames, _schema_filename); + } + + // + return s; + } + + + private String[] parseOptions(String[] args) throws CommandOptionException { + Object[] ret = null; + try { + ret = Util.parseCommandOptions(args, "hvsmtlED", "f", null); + } catch (CommandOptionException ex) { + String error_symbol = ex.getErrorSymbol(); + if (error_symbol.equals("command.option.noarg")) { + switch (ex.getOption()) { + case 'f': error_symbol = "command.option.noschema"; break; + default: + assert false; + } + } + throw optionError(error_symbol, ex.getOption()); + } + // + Map options = (Map)ret[0]; + Map properties = (Map)ret[1]; + String[] filenames = (String[])ret[2]; + // + _flag_help = options.get("h") != null; + _flag_version = options.get("v") != null; + _flag_silent = options.get("s") != null; + _flag_meta = options.get("m") != null; + _flag_untabify = options.get("t") != null; + _flag_emacs = options.get("E") != null; + _flag_linenum = options.get("l") != null || _flag_emacs; + _flag_debug = options.get("D") != null; + _schema_filename = (String)options.get("f"); + // + // + _properties = properties; + if (_properties.get("help") != null) { + _flag_help = true; + } + // + return filenames; + } + + + private String validate(String[] filenames, String schema_filename) throws IOException, SyntaxException { + String str = Util.readFile(schema_filename); + if (_flag_untabify) { + str = Util.untabify(str); + } + YamlParser parser = new YamlParser(str); + Object schema = parser.parse(); + Validator validator = new Validator(schema); + String s = validateFiles(validator, filenames); + return s; + } + + + private String validateFiles(Validator validator, String[] filenames) throws IOException, SyntaxException { + if (filenames.length == 0) { + filenames = new String[] { null }; + } + StringBuffer sb = new StringBuffer(); + for (int j = 0; j < filenames.length; j++) { + String filename = filenames[j]; + String str = null; + if (filename == null) { + str = Util.readInputStream(System.in); + filename = "(stdin)"; + } else { + str = Util.readFile(filename); + } + if (_flag_untabify) { + str = Util.untabify(str); + } + YamlParser parser = new YamlParser(str); + int i = 0; + while (parser.hasNext()) { + Object doc = parser.parse(); + validateDocument(sb, validator, doc, filename, i, parser); + i++; + } + } + return sb.toString(); + } + + + private void validateDocument(StringBuffer sb, Validator validator, Object doc, String filename, int i, YamlParser parser) { + if (doc == null) { + Object[] args = { filename, new Integer(i) }; + String msg = Messages.buildMessage("validation.empty", null, args); + sb.append(msg).append('\n'); + return; + } + List errors = validator.validate(doc); + Object[] args = { filename, new Integer(i) }; + if (errors == null || errors.size() == 0) { + if (! _flag_silent) { + String msg = Messages.buildMessage("validation.valid", args); + sb.append(msg).append('\n'); + } + } else { + String msg = Messages.buildMessage("validation.invalid", args); + sb.append(msg).append('\n'); + if (_flag_linenum) { + assert parser != null; + parser.setErrorsLineNumber(errors); + Collections.sort(errors); + } + for (Iterator it = errors.iterator(); it.hasNext(); ) { + ValidationException error = (ValidationException)it.next(); + if (_flag_emacs) { + assert _flag_linenum; + sb.append(filename).append(":").append(error.getLineNumber()).append(":"); + } else if (_flag_linenum) { + sb.append(" - (line ").append(error.getLineNumber()).append(")"); + } else { + sb.append(" -"); + } + sb.append(" [").append(error.getPath()).append("] ").append(error.getMessage()).append('\n'); + } + } + } + + + private String metaValidate(String[] filenames) throws IOException, SyntaxException { + Validator meta_validator = MetaValidator.instance(); + String s = validateFiles(meta_validator, filenames); + return s; + } + + + private String inspectSchemaFile(String schema_filename) throws IOException, SyntaxException { + String filename = schema_filename; + String content = filename != null ? Util.readFile(filename) : Util.readInputStream(System.in); + YamlParser parser = new YamlParser(content); + Object schema = parser.parse(); + if (schema == null) { + return null; + } + Validator validator = new Validator(schema); // SchemaException is thrown when schema is wrong + String s = validator.getRule().inspect(); + if (s.charAt(s.length() - 1) != '\n') { + s = s + '\n'; + } + return s; + } + + + private static CommandOptionException optionError(String error_symbol, char option) { + Object[] args = { Character.toString(option) }; + String message = Messages.buildMessage(error_symbol, null, args); + return new CommandOptionException(message, option, error_symbol); + } + + + private String version() { + Matcher m = Util.matcher(REVISION, "[.\\d]+"); + m.find(); + String version = m.group(0); + return version; + } + + + private String help() { + String help_msg = Messages.buildMessage("command.help", null, new Object[] { _command, _command }); + //String help = HELP.replaceAll("%s", _command); + return help_msg; + } + + + public static void main(String[] args) throws Exception { + int status = 0; + Main main = null; + try { + main = new Main("kwalify-java"); + String result = main.execute(args); + if (result != null) { + System.out.println(result); + } + } catch (Exception ex) { + if (main != null && main.isDebug()) { + throw ex; + } + if ( ex instanceof CommandOptionException + || ex instanceof SyntaxException + || ex instanceof IOException) { + System.err.println("ERROR: " + ex.getMessage()); + status = 1; + } + } + System.exit(status); + } + +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/Messages.java b/javatoscachecker/kwalify/src/main/java/kwalify/Messages.java new file mode 100644 index 0000000..b77f04b --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/Messages.java @@ -0,0 +1,51 @@ +/* + * @(#)Messages.java $Rev: 4 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +import java.util.ResourceBundle; +//import java.util.Locale; + +/** + * set of utility methods around messages. + * + * @revision $Rev: 4 $ + * @release $Release: 0.5.1 $ + */ +public class Messages { + + private static final String __basename = "kwalify.messages"; + private static ResourceBundle __messages = ResourceBundle.getBundle(__basename); + //private static ResourceBundle __messages = ResourceBundle.getBundle(__basename, Locale.getDefault()); + + public static String message(String key) { + return __messages.getString(key); + } + + public static String buildMessage(String key, Object[] args) { + return buildMessage(key, null, args); + } + + public static String buildMessage(String key, Object value, Object[] args) { + String msg = message(key); + assert msg != null; + if (args != null) { + for (int i = 0; i < args.length; i++) { // don't use MessageFormat + msg = msg.replaceFirst("%[sd]", escape(args[i])); + } + } + if (value != null && !Types.isCollection(value)) { + msg = "'" + escape(value) + "': " + msg; + } + return msg; + } + + private static String escape(Object obj) { + //return obj.toString().replaceAll("\\", "\\\\").replace("\n", "\\n"); // J2SK1.4 doesn't support String#replace(CharSequence, CharSequence)! + return obj.toString().replaceAll("\\\\", "\\\\\\\\").replaceAll("\\n", "\\\\n"); + } + +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/MetaValidator.java b/javatoscachecker/kwalify/src/main/java/kwalify/MetaValidator.java new file mode 100644 index 0000000..9ce05bd --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/MetaValidator.java @@ -0,0 +1,475 @@ +/* + * @(#)MetaValidator.java $Rev: 4 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +import java.util.Map; +import java.util.List; +import java.util.Iterator; +import java.util.regex.Pattern; +import java.util.regex.Matcher; +import java.util.regex.PatternSyntaxException; + +/** + * meta validator to validate schema definition + * + * @revision $Rev: 4 $ + * @release $Release: 0.5.1 $ + */ +public class MetaValidator extends Validator { + + public static final String META_SCHEMA = "" + + "name: MAIN\n" + + "type: map\n" + + "required: yes\n" + + "mapping: &main-rule\n" + + " \"name\":\n" + + " type: str\n" + + " \"desc\":\n" + + " type: str\n" + + " \"type\":\n" + + " type: str\n" + + " #required: yes\n" + + " enum:\n" + + " - seq\n" + + " #- sequence\n" + + " #- list\n" + + " - map\n" + + " #- mapping\n" + + " #- hash\n" + + " - str\n" + + " #- string\n" + + " - int\n" + + " #- integer\n" + + " - float\n" + + " - number\n" + + " #- numeric\n" + + " - bool\n" + + " #- boolean\n" + + " - text\n" + + " - date\n" + + " - time\n" + + " - timestamp\n" + + " #- object\n" + + " - any\n" + + " - scalar\n" + + " #- collection\n" + + " \"required\":\n" + + " type: bool\n" + + " \"enum\":\n" + + " type: seq\n" + + " sequence:\n" + + " - type: scalar\n" + + " unique: yes\n" + + " \"pattern\":\n" + + " type: str\n" + + " \"assert\":\n" + + " type: str\n" + + " pattern: /\\bval\\b/\n" + + " \"range\":\n" + + " type: map\n" + + " mapping:\n" + + " \"max\":\n" + + " type: scalar\n" + + " \"min\":\n" + + " type: scalar\n" + + " \"max-ex\":\n" + + " type: scalar\n" + + " \"min-ex\":\n" + + " type: scalar\n" + + " \"length\":\n" + + " type: map\n" + + " mapping:\n" + + " \"max\":\n" + + " type: int\n" + + " \"min\":\n" + + " type: int\n" + + " \"max-ex\":\n" + + " type: int\n" + + " \"min-ex\":\n" + + " type: int\n" + + " \"ident\":\n" + + " type: bool\n" + + " \"unique\":\n" + + " type: bool\n" + + " \"sequence\":\n" + + " name: SEQUENCE\n" + + " type: seq\n" + + " sequence:\n" + + " - type: map\n" + + " mapping: *main-rule\n" + + " name: MAIN\n" + + " #required: yes\n" + + " \"mapping\":\n" + + " name: MAPPING\n" + + " type: map\n" + + " mapping:\n" + + " =:\n" + + " type: map\n" + + " mapping: *main-rule\n" + + " name: MAIN\n" + + " #required: yes\n" + ; + + + /** + * + * ex. + * <pre> + * MetaValidator meta_validator = MetaValidator(); + * Map schema = YamlUtil.loadFile("schema.yaml"); + * List errors = meta_validator.validate(schema); + * if (errors != null && errors.size() > 0) { + * for (Iterator it = errors.iterator(); it.hasNext(); ) { + * ValidationException error = (ValidationException)it.next(); + * System.err.println(" - [" + error.getPath() + "] " + error.getMessage()); + * } + * } + * </pre> + */ + + private static Validator __instance; + + public static Validator instance() { + // should not use double checked pattern? + // but it would work well because __instance is read-only. + if (__instance == null) { + synchronized (MetaValidator.class) { + if (__instance == null) { + try { + Map schema = (Map)YamlUtil.load(META_SCHEMA); + __instance = new MetaValidator(schema); + } catch (SyntaxException ex) { + assert false; + } + } + } + } + return __instance; + } + + private MetaValidator(Map schema) { + super(schema); + } + + public void postValidationHook(Object value, Rule rule, ValidationContext theContext) { + if (value == null) { + return; // realy? + } + if (! "MAIN".equals(rule.getName())) { + return; + } + // + assert value instanceof Map; + Map map = (Map)value; + String type = (String)map.get("type"); + if (type == null) { + type = Types.getDefaultType(); + } + //Class type_class = Types.typeClass(type); + //if (type_class == null) { + // theContext.addError(validationError("type.unknown", rule, path + "/type", type, null)); + //} + // + //String pattern; + //if ((pattern = (String)map.get("pattern")) != null) { + if (map.containsKey("pattern")) { + String pattern = (String)map.get("pattern"); + Matcher m = Util.matcher(pattern, "\\A\\/(.*)\\/([mi]?[mi]?)\\z"); + String pat = m.find() ? m.group(1) : pattern; + try { + Pattern.compile(pat); + } catch (PatternSyntaxException ex) { + theContext.addError("pattern.syntaxerr", rule, "pattern", pattern, null); + } + } + // + //List enum_list; + //if ((enum_list = (List)map.get("enum")) != null) { + if (map.containsKey("enum")) { + List enum_list = (List)map.get("enum"); + if (Types.isCollectionType(type)) { + theContext.addError("enum.notscalar", rule, "enum:", (Object[])null); + } else { + for (Iterator it = enum_list.iterator(); it.hasNext(); ) { + Object elem = it.next(); + if (! Types.isCorrectType(elem, type)) { + theContext.addError("enum.type.unmatch", rule, "enum", elem, new Object[] { Types.typeName(type) }); + } + } + } + } + // + //String assert_str; + //if ((assert_str = (String)map.get("assert")) != null) { + if (map.containsKey("assert")) { + System.err.println("*** warning: sorry, 'assert:' is not supported in current version of Kwalify-java."); + //String assert_str = (String)map.get("assert"); + //if (! Util.matches(assert_str, "\\bval\\b")) { + // theContext.addError(validationError("assert.noval", rule, path + "/assert", assert_str, null); + //} + //try { + // Expression.parse(assert_str); + //} catch (InvalidExpressionException ex) { + // theContext.addError(validationError("assert.syntaxerr", rule, path + "/assert", assert_str, null)); + //} + } + // + //Map range; + //if ((range = (Map)map.get("range")) != null) { + if (map.containsKey("range")) { + Map range = (Map)map.get("range"); + //if (! (range instanceof Map)) { + // theContext.addError(validtionError("range.notmap", rule, path + "/range", range, null)); + //} else + if (Types.isCollectionType(type) || type.equals("bool") || type.equals("any")) { + theContext.addError("range.notscalar", rule, "range:", null, null); + } else { + for (Iterator it = range.keySet().iterator(); it.hasNext(); ) { + String k = (String)it.next(); + Object v = range.get(k); + if (! Types.isCorrectType(v, type)) { + theContext.addError("range.type.unmatch", rule, "range/" + k, v, new Object[] { Types.typeName(type) }); + } + } + } + if (range.containsKey("max") && range.containsKey("max-ex")) { + theContext.addError("range.twomax", rule, "range", null, null); + } + if (range.containsKey("min") && range.containsKey("min-ex")) { + theContext.addError("range.twomin", rule, "range", null, null); + } + Object max = range.get("max"); + Object min = range.get("min"); + Object max_ex = range.get("max-ex"); + Object min_ex = range.get("min-ex"); + Object[] args = null; + //String error_symbol = null; + if (max != null) { + if (min != null && Util.compareValues(max, min) < 0) { + args = new Object[] { max, min }; + theContext.addError("range.maxltmin", rule, "range", null, args); + } else if (min_ex != null && Util.compareValues(max, min_ex) <= 0) { + args = new Object[] { max, min_ex }; + theContext.addError("range.maxleminex", rule, "range", null, args); + } + } else if (max_ex != null) { + if (min != null && Util.compareValues(max_ex, min) <= 0) { + args = new Object[] { max_ex, min }; + theContext.addError("range.maxexlemin", rule, "range", null, args); + } else if (min_ex != null && Util.compareValues(max_ex, min_ex) <= 0) { + args = new Object[] { max_ex, min_ex }; + theContext.addError("range.maxexleminex", rule, "range", null, args); + } + } + } + // + //Map length; + //if ((length = (Map)map.get("length")) != null) { + if (map.containsKey("length")) { + Map length = (Map)map.get("length"); + //if (! (length instanceof Map)) { + // theContext.addError(validtionError("length.notmap", rule, path + "/length", length, null)); + //} else + if (! (type.equals("str") || type.equals("text"))) { + theContext.addError("length.nottext", rule, "length:", (Object[])null); + } + //for (Iterator it = length.keySet().iterator(); it.hasNext(); ) { + // String k = (String)it.next(); + // Object v = length.get(k); + // if (k == null || ! (k.equals("max") || k.equals("min") || k.equals("max-ex") || k.equals("min-ex"))) { + // theContext.addError(validationError("length.undefined", rule, path + "/length/" + k, "" + k + ":", null)); + // } else if (! (v instanceof Integer)) { + // theContext.addError(validationError("length.notint", rule, path + "/length/" + k, v, null)); + // } + //} + if (length.containsKey("max") && length.containsKey("max-ex")) { + theContext.addError("length.twomax", rule, "length", (Object[])null); + } + if (length.containsKey("min") && length.containsKey("min-ex")) { + theContext.addError("length.twomin", rule, "length", (Object[])null); + } + Integer max = (Integer)length.get("max"); + Integer min = (Integer)length.get("min"); + Integer max_ex = (Integer)length.get("max-ex"); + Integer min_ex = (Integer)length.get("min-ex"); + Object[] args = null; + //String error_symbol = null; + if (max != null) { + if (min != null && max.compareTo(min) < 0) { + args = new Object[] { max, min }; + theContext.addError("length.maxltmin", rule, "length", null, args); + } else if (min_ex != null && max.compareTo(min_ex) <= 0) { + args = new Object[] { max, min_ex }; + theContext.addError("length.maxleminex", rule, "length", null, args); + } + } else if (max_ex != null) { + if (min != null && max_ex.compareTo(min) <= 0) { + args = new Object[] { max_ex, min }; + theContext.addError("length.maxexlemin", rule, "length", null, args); + } else if (min_ex != null && max_ex.compareTo(min_ex) <= 0) { + args = new Object[] { max_ex, min_ex }; + theContext.addError("length.maxexleminex", rule, "length", null, args); + } + } + } + // + //Boolean unique; + //if ((unique = (Boolean)map.get("unique")) != null) { + if (map.containsKey("unique")) { + Boolean unique = (Boolean)map.get("unique"); + if (unique.booleanValue() == true && Types.isCollectionType(type)) { + theContext.addError("unique.notscalar", rule, "unique:", (Object[])null); + } + if (theContext.getPath().length() == 0) { + theContext.addError("unique.onroot", rule, "", "unique:", null); + } + } + // + //Boolean ident; + //if ((ident = (Boolean)map.get("ident")) != null) { + if (map.containsKey("ident")) { + Boolean ident = (Boolean)map.get("ident"); + if (ident.booleanValue() == true && Types.isCollectionType(type)) { + theContext.addError("ident.notscalar", rule, "ident:", (Object[])null); + } + if (theContext.getPath().length() == 0) { + theContext.addError("ident.onroot", rule, "/", "ident:", (Object[])null); + } + } + // + //List seq; + //if ((seq = (List)map.get("sequence")) != null) { + if (map.containsKey("sequence")) { + List seq = (List)map.get("sequence"); + //if (! (seq instanceof List)) { + // theContext.addError(validationError("sequence.notseq", rule, path + "/sequence", seq, null)); + //} else + if (seq == null || seq.size() == 0) { + theContext.addError("sequence.noelem", rule, "sequence", seq, null); + } else if (seq.size() > 1) { + theContext.addError("sequence.toomany", rule, "sequence", seq, null); + } else { + Object item = seq.get(0); + assert item instanceof Map; + Map m = (Map)item; + Boolean ident2 = (Boolean)m.get("ident"); + if (ident2 != null && ident2.booleanValue() == true && ! "map".equals(m.get("type"))) { + theContext.addError("ident.notmap", null, "sequence/0", "ident:", null); + } + } + } + // + //Map mapping; + //if ((mapping = (Map)map.get("mapping")) != null) { + if (map.containsKey("mapping")) { + Map mapping = (Map)map.get("mapping"); + //if (mapping != null && ! (mapping instanceof Map)) { + // theContext.addError(validationError("mapping.notmap", rule, path + "/mapping", mapping, null)); + //} else + Object default_value = null; + if (mapping != null && mapping instanceof Defaultable) { + default_value = ((Defaultable)mapping).getDefault(); + } + if (mapping == null || (mapping.size() == 0 && default_value == null)) { + theContext.addError("mapping.noelem", rule, "mapping", mapping, null); + } + } + // + if (type.equals("seq")) { + if (! map.containsKey("sequence")) { + theContext.addError("seq.nosequence", rule, null, (Object[])null); + } + //if (map.containsKey("enum")) { + // theContext.addError(validationError("seq.conflict", rule, path, "enum:", null)); + //} + if (map.containsKey("pattern")) { + theContext.addError("seq.conflict", rule, "pattern:", (Object[])null); + } + if (map.containsKey("mapping")) { + theContext.addError("seq.conflict", rule, "mapping:", (Object[])null); + } + //if (map.containsKey("range")) { + // theContext.addError(validationError("seq.conflict", rule, path, "range:", null)); + //} + //if (map.containsKey("length")) { + // theContext.addError(validationError("seq.conflict", rule, path, "length:", null)); + //} + } else if (type.equals("map")) { + if (! map.containsKey("mapping")) { + theContext.addError("map.nomapping", rule, null, (Object[])null); + } + //if (map.containsKey("enum")) { + // theContext.addError(validationError("map.conflict", rule, path, "enum:", null)); + //} + if (map.containsKey("pattern")) { + theContext.addError("map.conflict", rule, "pattern:", (Object[])null); + } + if (map.containsKey("sequence")) { + theContext.addError("map.conflict", rule, "sequence:", (Object[])null); + } + //if (map.containsKey("range")) { + // theContext.addError(validationError("map.conflict", rule, path, "range:", null)); + //} + //if (map.containsKey("length")) { + // theContext.addError(validationError("map.conflict", rule, path, "length:", null)); + //} + } else { + if (map.containsKey("sequence")) { + theContext.addError("scalar.conflict", rule, "sequence:", (Object[])null); + } + if (map.containsKey("mapping")) { + theContext.addError("scalar.conflict", rule, "mapping:", (Object[])null); + } + if (map.containsKey("enum")) { + if (map.containsKey("range")) { + theContext.addError("enum.conflict", rule, "range:", (Object[])null); + } + if (map.containsKey("length")) { + theContext.addError("enum.conflict", rule, "length:", (Object[])null); + } + if (map.containsKey("pattern")) { + theContext.addError("enum.conflict", rule, "pattern:", (Object[])null); + } + } + } + } + +/* + public static void main(String[] args) { + try { + // parse schema + String filename = args.length > 0 ? args[0] : "schema.yaml"; + String schema_str = Util.readFile(filename); + YamlParser parser = new YamlParser(schema_str); + Object schema = parser.parse(); + + // validate schema + Validator meta_validator = MetaValidator.instance(); + List errors = meta_validator.validate(schema); + + // show errors + if (errors != null && errors.size() > 0) { + parser.setErrorsLineNumber(errors); + for (Iterator it = errors.iterator(); it.hasNext(); ) { + ValidationException error = (ValidationException)it.next(); + int linenum = error.getLineNumber(); + String path = error.getPath(); + String msg = error.getMessage(); + System.out.println("- line " + linenum + ": [" + path + "] " + msg); + } + } else { + System.out.println("meta validation: OK."); + } + } catch (SyntaxException ex) { + ex.printStackTrace(); + } catch (java.io.IOException ex) { + ex.printStackTrace(); + } + } +*/ + +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/Parser.java b/javatoscachecker/kwalify/src/main/java/kwalify/Parser.java new file mode 100644 index 0000000..53c6272 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/Parser.java @@ -0,0 +1,19 @@ +/* + * @(#)Parser.java $Rev: 3 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +/** + * interface for any parser + * + * @revision $Rev: 3 $ + * @release $Release: 0.5.1 $ + */ +public interface Parser { + + public Object parse() throws SyntaxException; + +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/PlainYamlParser.java b/javatoscachecker/kwalify/src/main/java/kwalify/PlainYamlParser.java new file mode 100644 index 0000000..6224044 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/PlainYamlParser.java @@ -0,0 +1,870 @@ +/* + * @(#)PlainYamlParser.java $Rev: 4 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.IdentityHashMap; +import java.util.Iterator; +import java.util.regex.Matcher; +import java.util.Calendar; +import java.util.Date; +import java.util.TimeZone; + +/** + * plain yaml parser class which is a parent of YamlParser class. + * + * ex. + * <pre> + * String str = kwalify.Util.readFile("document.yaml"); + * kwalify.Parser parser = new kwalify.PlainYamlParser(str); + * Object doc = parser.parse(); + * </pre> + * + * @revision $Rev: 4 $ + * @release $Release: 0.5.1 $ + */ +public class PlainYamlParser implements Parser { + + public static class Alias { + private String _label; + private int _linenum; + + public Alias(String label, int linenum) { + _label = label; + _linenum = linenum; + } + + public String getLabel() { return _label; } + public void setLabel(String label) { _label = label; } + + public int getLineNumber() { return _linenum; } + public void setLineNumber(int linenum) { _linenum = linenum; } + } + + + private String[] _lines; + private String _line = null; + private int _linenum = 0; + private Map _anchors = new HashMap(); + private Map _aliases = new HashMap(); // key: label, value: Integer + private Object _end_flag = null; + private String _sbuf = null; + private int _index = 0; + + public PlainYamlParser(String yaml_str) { + // split yaml_str into _lines + List list = Util.toListOfLines(yaml_str); + int len = list.size(); + _lines = new String[len + 1]; + for (int i = 0; i < len; i++) { + _lines[i + 1] = (String)list.get(i); + } + } + + public Object parse() throws SyntaxException { + Object data = parseChild(0); + if (data == null && _end_flag == ENDFLAG_DOC_BEGIN) { + data = parseChild(0); + } + if (_aliases.size() > 0) { + resolveAliases(data); + } + //System.err.println("*** debug: data = " + Util.inspect(data)); + //System.err.println("*** debug: data = " + data.toString()); + return data; + } + + public boolean hasNext() { + return _end_flag != ENDFLAG_EOF; + } + + public Object[] parseAll() throws SyntaxException { + List docs = new ArrayList(); + while (hasNext()) { + Object doc = parse(); + docs.add(doc); + } + return docs.toArray(); + } + + + protected List createSequence(int linenum) { + return new ArrayList(); + } + + //private List createSequence() { + // return createSequence(_linenum); + //} + + protected void addSequenceValue(List seq, Object value, int linenum) { + seq.add(value); + } + + protected void setSequenceValueAt(List seq, int index, Object value, int linenum) { + seq.set(index, value); + } + + protected Map createMapping(int linenum) { + return new DefaultableHashMap(); + } + + //private Map createMapping() { + // return createMapping(_linenum); + //} + + protected void setMappingValueWith(Map map, Object key, Object value, int linenum) { + map.put(key, value); + } + + protected void setMappingDefault(Map map, Object value, int linenum) { + if (map instanceof Defaultable) { + ((Defaultable)map).setDefault(value); + } + } + + protected void mergeMapping(Map map, Map map2, int linenum) { + for (Iterator it = map2.keySet().iterator(); it.hasNext(); ) { + Object key = it.next(); + if (! map.containsKey(key)) { + Object value = map2.get(key); + map.put(key, value); + } + } + } + + protected void mergeList(Map map, List maplist, int linenum) throws SyntaxException { + for (Iterator it = maplist.iterator(); it.hasNext(); ) { + Object elem = it.next(); + mergeCollection(map, elem, linenum); + } + } + + protected void mergeCollection(Map map, Object collection, int linenum) throws SyntaxException { + if (collection instanceof Map) { + mergeMapping(map, (Map)collection, linenum); + } else if (collection instanceof List) { + mergeList(map, (List)collection, linenum); + } else { + throw syntaxError("'<<' requires collection (mapping, or sequence of mapping)."); + } + } + + protected Object createScalar(Object value, int linenum) { + return value; + } + + private Object createScalar(Object value) { + return createScalar(value, _linenum); + } + + protected String currentLine() { + return _line; + } + + protected int currentLineNumber() { + return _linenum; + } + + protected String getLine() { + String line; + do { + line = _getLine_(); + } while (line != null && Util.matches(line, "^\\s*($|#)")); + return line; + } + + protected String _getLine_() { + if (++_linenum < _lines.length) { + _line = _lines[_linenum]; + if (Util.matches(_line, "^\\.\\.\\.$")) { + _line = null; + _end_flag = ENDFLAG_DOC_END; + } else if (Util.matches(_line, "^---( [!%].*)?$")) { + _line = null; + _end_flag = ENDFLAG_DOC_BEGIN; + } + } else { + _line = null; + _end_flag = ENDFLAG_EOF; + } + return _line; + } + + protected static final String ENDFLAG_EOF = "<EOF>"; + protected static final String ENDFLAG_DOC_BEGIN = "---"; + protected static final String ENDFLAG_DOC_END = "..."; + + private void resetBuffer(String str) { + _sbuf = str.charAt(str.length() - 1) == '\n' ? str : str + "\n"; + _index = -1; + } + + + private int _getChar_() { + if (_index + 1 < _sbuf.length()) { + _index++; + } else { + String line = getLine(); + if (line == null) return -1; + resetBuffer(line); + _index++; + } + int ch = _sbuf.charAt(_index); + return ch; + } + + private int getChar() { + int ch; + do { + ch = _getChar_(); + } while (ch >= 0 && isWhite(ch)); + return ch; + } + + private int getCharOrNewline() { + int ch; + do { + ch = _getChar_(); + } while (ch >= 0 && isWhite(ch) && ch != '\n'); + return ch; + } + + private int currentChar() { + return _sbuf.charAt(_index); + } + + private SyntaxException syntaxError(String message, int linenum) { + return new YamlSyntaxException(message, linenum); + } + + private SyntaxException syntaxError(String message) { + return new SyntaxException(message, _linenum); + } + + private Object parseChild(int column) throws SyntaxException { + String line = getLine(); + if (line == null) { + return createScalar(null); + } + Matcher m = Util.matcher(line, "^( *)(.*)"); + if (! m.find()) { + assert false; + return null; + } + int indent = m.group(1).length(); + if (indent < column) { + return createScalar(null); + } + String value = m.group(2); + return parseValue(column, value, indent); + } + + private Object parseValue(int column, String value, int value_start_column) throws SyntaxException { + Object data; + if (Util.matches(value, "^-( |$)")) { + data = parseSequence(value_start_column, value); + } else if (Util.matches(value, "^((?::?[-.\\w]+|'.*?'|\".*?\"|=|<<) *):(( +)(.*))?$")) { + data = parseMapping(value_start_column, value); + } else if (Util.matches(value, "^[\\[\\{]")) { + data = parseFlowStyle(column, value); + } else if (Util.matches(value, "^\\&[-\\w]+( |$)")) { + data = parseAnchor(column, value); + } else if (Util.matches(value, "^\\*[-\\w]+( |$)")) { + data = parseAlias(column, value); + } else if (Util.matches(value, "^[|>]")) { + data = parseBlockText(column, value); + } else if (Util.matches(value, "^!")) { + data = parseTag(column, value); + } else if (Util.matches(value, "^\\#")) { + data = parseChild(column); + } else { + data = parseScalar(column, value); + } + return data; + } + + private static boolean isWhite(int ch) { + return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r'; + } + + + private Object parseFlowStyle(int column, String value) throws SyntaxException { + resetBuffer(value); + getChar(); + Object data = parseFlow(0); + int ch = currentChar(); + assert ch == ']' || ch == '}'; + ch = getCharOrNewline(); + if (ch != '\n' && ch != '#' && ch >= 0) { + throw syntaxError("flow style sequence is closed buf got '" + ((char)ch) + "'."); + } + if (ch >= 0) getLine(); + return data; + } + + private Object parseFlow(int depth) throws SyntaxException { + int ch = currentChar(); + //ch = getChar(); + if (ch < 0) { + throw syntaxError("found EOF when parsing flow style."); + } + Object data; + if (ch == '[') { + data = parseFlowSequence(depth); + } else if (ch == '{') { + data = parseFlowMapping(depth); + } else { + data = parseFlowScalar(depth); + } + return data; + } + + private List parseFlowSequence(int depth) throws SyntaxException { + assert currentChar() == '['; + List seq = createSequence(_linenum); + int ch = getChar(); + if (ch != '}') { + int linenum = currentLineNumber(); + //seq.add(parseFlowSequenceItem(depth+1); + addSequenceValue(seq, parseFlowSequenceItem(depth + 1), linenum); + while ((ch = currentChar()) == ',') { + ch = getChar(); + if (ch == '}') { + throw syntaxError("sequence item required (or last comma is extra)."); + } + //if (ch == '?') break; + linenum = currentLineNumber(); + //seq.add(parseFlowSequenceItem(depth+1); + addSequenceValue(seq, parseFlowSequenceItem(depth + 1), linenum); + } + } + if (currentChar() != ']') { + throw syntaxError("flow style sequence requires ']'."); + } + if (depth > 0) getChar(); + return seq; + } + + private Object parseFlowSequenceItem(int depth) throws SyntaxException { + return parseFlow(depth); + } + + private Map parseFlowMapping(int depth) throws SyntaxException { + assert currentChar() == '{'; + Map map = createMapping(_linenum); + int ch = getChar(); + if (ch != '}') { + int linenum = currentLineNumber(); + Object[] pair = parseFlowMappingItem(depth + 1); + Object key = pair[0]; + Object value = pair[1]; + //map[ke] = value + setMappingValueWith(map, key, value, linenum); + while ((ch = currentChar()) == ',') { + ch = getChar(); + if (ch == '}') { + throw syntaxError("mapping item required (or last comman is extra."); + } + //if (ch == '}') break; + linenum = currentLineNumber(); + pair = parseFlowMappingItem(depth + 1); + key = pair[0]; + value = pair[1]; + //map.put(key) = value; + setMappingValueWith(map, key, value, linenum); + } + } + if (currentChar() != '}') { + throw syntaxError("flow style mapping requires '}'."); + } + if (depth > 0) getChar(); + return map; + } + + private Object[] parseFlowMappingItem(int depth) throws SyntaxException { + Object key = parseFlow(depth); + int ch = currentChar(); + if (ch != ':') { + String s = ch >= 0 ? "'" + ((char)ch) + "'" : "EOF"; + throw syntaxError("':' expected but got " + s); + } + getChar(); + Object value = parseFlow(depth); + return new Object[] { key, value }; + } + + private Object parseFlowScalar(int depth) throws SyntaxException { + int ch = currentChar(); + Object scalar = null; + StringBuffer sb = new StringBuffer(); + if (ch == '"' || ch == '\'') { + int endch = ch; + while ((ch = _getChar_()) >= 0 && ch != endch) { + sb.append((char)ch); + } + getChar(); + scalar = sb.toString(); + } else { + sb.append((char)ch); + while ((ch = _getChar_()) >= 0 && ch != ':' && ch != ',' && ch != ']' && ch != '}') { + sb.append((char)ch); + } + scalar = toScalar(sb.toString().trim()); + } + return createScalar(scalar); + } + + private Object parseTag(int column, String value) throws SyntaxException { + assert Util.matches(value, "^!\\S+"); + Matcher m = Util.matcher(value, "^!(\\S+)((\\s+)(.*))?$"); + if (! m.find()) { + assert false; + return null; + } + String tag = m.group(1); + String space = m.group(3); + String value2 = m.group(4); + Object data; + if (value2 != null && value2.length() > 0) { + int value_start_column = column + 1 + tag.length() + space.length(); + data = parseValue(column, value2, value_start_column); + } else { + data = parseChild(column); + } + return data; + } + + private Object parseAnchor(int column, String value) throws SyntaxException { + assert Util.matches(value, "^\\&([-\\w]+)(( *)(.*))?$"); + Matcher m = Util.matcher(value, "^\\&([-\\w]+)(( *)(.*))?$"); + if (! m.find()) { + assert false; + return null; + } + String label = m.group(1); + String space = m.group(3); + String value2 = m.group(4); + Object data; + if (value2 != null && value2.length() > 0) { + int value_start_column = column + 1 + label.length() + space.length(); + data = parseValue(column, value2, value_start_column); + } else { + data = parseChild(column); + } + registerAnchor(label, data); + return data; + } + + private void registerAnchor(String label, Object data) throws SyntaxException { + if (_anchors.containsKey(label)) { + throw syntaxError("anchor '" + label + "' is already used."); + } + _anchors.put(label, data); + } + + private Object parseAlias(int column, String value) throws SyntaxException { + assert value.matches("^\\*([-\\w]+)(( *)(.*))?$"); + Matcher m = Util.matcher(value, "^\\*([-\\w]+)(( *)(.*))?$"); + if (! m.find()) { + assert false; + return null; + } + String label = m.group(1); + //String space = m.group(3); + String value2 = m.group(4); + if (value2 != null && value2.length() > 0 && value2.charAt(0) != '#') { + throw syntaxError("alias cannot take any data."); + } + Object data = _anchors.get(label); + if (data == null) { + //throw syntaxError("anchor '" + label "' not found (cannot refer to backward or child anchor)."); + data = registerAlias(label); + } + getLine(); + return data; + } + + private Alias registerAlias(String label) throws SyntaxException { + Integer count = (Integer)_aliases.get(label); + if (count == null) { + _aliases.put(label, new Integer(1)); + } else { + _aliases.put(label, new Integer(count.intValue() + 1)); + } + return new Alias(label, _linenum); + } + + + private void resolveAliases(Object data) throws SyntaxException { // List or Map + Map resolved = new IdentityHashMap(); + resolveAliases(data, resolved); + } + + + private void resolveAliases(Object data, Map resolved) throws SyntaxException { + if (resolved.containsKey(data)) { + return; + } + resolved.put(data, data); + if (data instanceof List) { + resolveAliases((List)data, resolved); + } else if (data instanceof Map) { + resolveAliases((Map)data, resolved); + } else { + assert !(data instanceof Alias); + } + if (data instanceof Defaultable) { + Object default_value = ((Defaultable)data).getDefault(); + if (default_value != null) { + resolveAliases(default_value, resolved); + } + } + } + + private void resolveAliases(List seq, Map resolved) throws SyntaxException { + int len = seq.size(); + for (int i = 0; i < len; i++) { // don't use itrator not to raise java.util.ConcurrentModificationException + Object val = seq.get(i); + if (val instanceof Alias) { + Alias alias = (Alias)val; + String label = alias.getLabel(); + if (_anchors.containsKey(label)) { + //seq.set(i, _anchors.get(label); + setSequenceValueAt(seq, i, _anchors.get(label), alias.getLineNumber()); + } else { + throw syntaxError("anchor '" + alias.getLabel() + "' not found."); + } + } else if (val instanceof List || val instanceof Map) { + resolveAliases(val, resolved); + } + } + } + + private void resolveAliases(Map map, Map resolved) throws SyntaxException { + for (Iterator it = map.keySet().iterator(); it.hasNext(); ) { + Object key = it.next(); + Object val = map.get(key); + if (val instanceof Alias) { + Alias alias = (Alias)val; + String label = alias.getLabel(); + if (_anchors.containsKey(label)) { + //map.put(key, _anchors.get(label)); + setMappingValueWith(map, key, _anchors.get(label), alias.getLineNumber()); + } else { + throw syntaxError("anchor '" + alias.getLabel() + "' not found.", alias.getLineNumber()); + } + } else if (val instanceof List || val instanceof Map) { + resolveAliases(val, resolved); + } + } + } + + + +/* + private Object parseBlockText(int column, String value) throws SyntaxException { + assert Util.matches(value, "^[>|\\|]"); + Matcher m = Util.matcher(value, "^([>|\\|])([-+]?)\\s*(.*)$"); + if (! m.find()) { + assert false; + return null; + } + String blockchar = m.group(1); + String indicator = m.group(2); + String sep = blockchar.equals("|") ? "\n" : " "; + //String text = m.group(3).length() > 0 ? "" : m.group(3) + sep; + String text = m.group(3); + StringBuffer sb = new StringBuffer(); + StringBuffer empty = new StringBuffer(); + int min_indent = -1; + String line; + Pattern pat2 = Pattern.compile("^( *)(.*)"); + while ((line = _getLine_()) != null) { + (m = pat2.matcher(line)).find(); + int indent = m.group(1).length(); + if (m.group(2).length() == 0) { + empty.append("\n"); + } else if (indent < column) { + break; + } else { + if (min_indent < 0 || min_indent > indent) { + min_indent = indent; + } + sb.append(empty.toString()); + sb.append(line); + empty.delete(0, empty.length()); + } + } + if (indicator.equals("+")) { + sb.append(empty); + } else if (indicator.equals("-")) { + sb.deleteCharAt(sb.length() - 1); + } + String s; + if (min_indent <= 0) { + s = sb.toString(); + } else { + StringBuffer regex = new StringBuffer("(?m)^"); + for (int i = 0; i < min_indent; i++) regex.append(" "); + s = sb.toString().replaceAll(regex.toString(), ""); + } + if (blockchar.equals(">")) { + StringBuffer sb2 = new StringBuffer(); + int len = s.length(); + int n = 0; + for (int i = 0; i < len; i++) { + char ch = s.charAt(i); + if (ch == '\n') { + n++; + } else { + if (n == 1) { + sb2.append(' '); n = 0; + } else if (n > 1) { + sb2.append('\n'); n = 0; + } + sb2.append(ch); + } + } + s = sb2.toString(); + } + if (currentLine() != null && Util.matches(currentLine(), "^\\s*#")) getLine(); + return createScalar(text + s); + } +*/ + + private Object parseBlockText(int column, String value) throws SyntaxException { + assert Util.matches(value, "^[>|]"); + Matcher m = Util.matcher(value, "^([>|])([-+]?)(\\d*)\\s*(.*)$"); + if (! m.find()) { + assert false; + return null; + } + char blockchar = m.group(1).length() > 0 ? m.group(1).charAt(0) : '\0'; + char indicator = m.group(2).length() > 0 ? m.group(2).charAt(0) : '\0'; + int indent = m.group(3).length() > 0 ? Integer.parseInt(m.group(3)) : -1; + String text = m.group(4); + char sep = blockchar == '|' ? '\n' : ' '; + String line; + StringBuffer sb = new StringBuffer(); + int n = 0; + while ((line = _getLine_()) != null) { + m = Util.matcher(line, "^( *)(.*)$"); + m.find(); + String space = m.group(1); + String str = m.group(2); + if (indent < 0) indent = space.length(); + if (str.length() == 0) { // empty line + n++; + } else { + int slen = space.length(); + if (slen < column) { + break; + } else if (slen < indent) { + throw syntaxError("invalid indent in block text."); + } else { + if (n > 0) { + if (blockchar == '>' && sb.length() > 0) { + sb.deleteCharAt(sb.length() - 1); + } + for (int i = 0; i < n; i++) { + sb.append('\n'); + } + n = 0; + } + str = line.substring(indent); + } + } + sb.append(str); + if (blockchar == '>') { + if (sb.charAt(sb.length() - 1) == '\n') { + sb.setCharAt(sb.length() - 1, ' '); + } + } + } + if (line != null && Util.matches(line, "^ *#")) { + getLine(); + } + switch (indicator) { + case '+': + if (n > 0) { + if (blockchar == '>') { + sb.setCharAt(sb.length() - 1, '\n'); + } + for (int i = 0; i < n; i++) { + sb.append('\n'); + } + } + break; + case '-': + if (sb.charAt(sb.length() - 1) == sep) { + sb.deleteCharAt(sb.length() - 1); + } + break; + default: + if (blockchar == '>') { + sb.setCharAt(sb.length() - 1, '\n'); + } + } + return createScalar(text + sb.toString()); + } + + + private List parseSequence(int column, String value) throws SyntaxException { + assert Util.matches(value, "^-(( +)(.*))?$"); + List seq = createSequence(_linenum); + while (true) { + Matcher m = Util.matcher(value, "^-(( +)(.*))?$"); + if (! m.find()) { + throw syntaxError("sequence item is expected."); + } + String space = m.group(2); + String value2 = m.group(3); + int column2 = column + 1; + int linenum = currentLineNumber(); + // + Object elem; + if (value2 == null || value2.length() == 0) { + elem = parseChild(column2); + } else { + int value_start_column = column2 + space.length(); + elem = parseValue(column2, value2, value_start_column); + } + addSequenceValue(seq, elem, linenum); + // + String line = currentLine(); + if (line == null) break; + Matcher m2 = Util.matcher(line, "^( *)(.*)"); + m2.find(); + int indent = m2.group(1).length(); + if (indent < column) { + break; + } else if (indent > column) { + throw syntaxError("invalid indent of sequence."); + } + value = m2.group(2); + } + return seq; + } + + + private Map parseMapping(int column, String value) throws SyntaxException { + assert Util.matches(value, "^((?::?[-.\\w]+|'.*?'|\".*?\"|=|<<) *):(( +)(.*))?$"); + Map map = createMapping(_linenum); + while (true) { + Matcher m = Util.matcher(value, "^((?::?[-.\\w]+|'.*?'|\".*?\"|=|<<) *):(( +)(.*))?$"); + if (! m.find()) { + throw syntaxError("mapping item is expected."); + } + String v = m.group(1).trim(); + Object key = toScalar(v); + String value2 = m.group(4); + int column2 = column + 1; + int linenum = currentLineNumber(); + // + Object elem; + if (value2 == null || value2.length() == 0) { + elem = parseChild(column2); + } else { + int value_start_column = column2 + m.group(1).length() + m.group(3).length(); + elem = parseValue(column2, value2, value_start_column); + } + if (v.equals("=")) { + setMappingDefault(map, elem, linenum); + } else if (v.equals("<<")) { + mergeCollection(map, elem, linenum); + } else { + setMappingValueWith(map, key, elem, linenum); + } + // + String line = currentLine(); + if (line == null) { + break; + } + Matcher m2 = Util.matcher(line, "^( *)(.*)"); + m2.find(); + int indent = m2.group(1).length(); + if (indent < column) { + break; + } else if (indent > column) { + throw syntaxError("invalid indent of mapping."); + } + value = m2.group(2); + } + return map; + } + + + private Object parseScalar(int indent, String value) throws SyntaxException { + Object data = createScalar(toScalar(value)); + getLine(); + return data; + } + + + private Object toScalar(String value) { + Matcher m; + if ((m = Util.matcher(value, "^\"(.*)\"([ \t]*#.*$)?")).find()) { + return m.group(1); + } else if ((m = Util.matcher(value, "^'(.*)'([ \t]*#.*$)?")).find()) { + return m.group(1); + } else if ((m = Util.matcher(value, "^(.*\\S)[ \t]*#")).find()) { + value = m.group(1); + } + // + if (Util.matches(value, "^-?0x\\d+$")) return new Integer(Integer.parseInt(value, 16)); + else if (Util.matches(value, "^-?0\\d+$")) return new Integer(Integer.parseInt(value, 8)); + else if (Util.matches(value, "^-?\\d+$")) return new Integer(Integer.parseInt(value, 10)); + else if (Util.matches(value, "^-?\\d+\\.\\d+$")) return new Double(Double.parseDouble(value)); + else if (Util.matches(value, "^(true|yes|on)$")) return Boolean.TRUE; + else if (Util.matches(value, "^(false|no|off)$")) return Boolean.FALSE; + else if (Util.matches(value, "^(null|~)$")) return null; + else if (Util.matches(value, "^:(\\w+)$")) return value; + else if ((m = Util.matcher(value, "^(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d)$")).find()) { + int year = Integer.parseInt(m.group(1)); + int month = Integer.parseInt(m.group(2)); + int day = Integer.parseInt(m.group(3)); + Calendar cal = Calendar.getInstance(); + cal.set(year, month, day, 0, 0, 0); + Date date = cal.getTime(); + return date; + } else if ((m = Util.matcher(value, "^(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d)(?:[Tt]|[ \t]+)(\\d\\d?):(\\d\\d):(\\d\\d)(\\.\\d*)?(?:Z|[ \t]*([-+]\\d\\d?)(?::(\\d\\d))?)?$")).find()) { + int year = Integer.parseInt(m.group(1)); + int month = Integer.parseInt(m.group(2)); + int day = Integer.parseInt(m.group(3)); + int hour = Integer.parseInt(m.group(4)); + int min = Integer.parseInt(m.group(5)); + int sec = Integer.parseInt(m.group(6)); + //int usec = Integer.parseInt(m.group(7)); + //int tzone_h = Integer.parseInt(m.group(8)); + //int tzone_m = Integer.parseInt(m.group(9)); + String timezone = "GMT" + m.group(8) + ":" + m.group(9); + Calendar cal = Calendar.getInstance(); + cal.set(year, month, day, hour, min, sec); + cal.setTimeZone(TimeZone.getTimeZone(timezone)); + Date date = cal.getTime(); + return date; + } else { + return value; + } + } + +/* + public static void main(String[] args) throws Exception { + String filename = args.length > 0 ? args[0] : "test.yaml"; + String s = Util.readFile(filename); + PlainYamlParser parser = new PlainYamlParser(s); + while (parser.hasNext()) { + Object doc = parser.parse(); + System.out.println(Util.inspect(doc)); + } + } +*/ + +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/Rule.java b/javatoscachecker/kwalify/src/main/java/kwalify/Rule.java new file mode 100644 index 0000000..558525d --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/Rule.java @@ -0,0 +1,673 @@ +/* + * @(#)Rule.java $Rev: 4 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.IdentityHashMap; +import java.util.Iterator; +import java.util.regex.Pattern; +import java.util.regex.Matcher; +import java.util.regex.PatternSyntaxException; + +/** + * rule for validation. + * Validator class generates rule instances. + * + * @revision $Rev: 4 $ + * @release $Release: 0.5.1 $ + */ +public class Rule { + + /* + * instance variables + */ + + private Rule _parent; + private String _name = null; + private String _desc = null; + private String _short = null; //added by jora: only used for map types + private String _ref = null; //added by jora: only used for ref types (references to other rules by name) + private boolean _required = false; + private String _type = null; + private Class _type_class = null; + private String _pattern = null; + private Pattern _pattern_regexp = null; + private List _enum = null; + private List _sequence = null; + private DefaultableHashMap _mapping = null; + private String _assert = null; + private Map _range = null; + private Map _length = null; + private boolean _ident = false; + private boolean _unique = false; + + + /* + * accessors + */ + + public String getName() { return _name; } + public void setName(String name) { _name = name; } + + public String getDesc() { return _desc; } + public void setDesc(String desc) { _desc = desc; } + + public String getShort() { return _short; } + public void setShort(String val) { _short = val; } + + public String getReference() { return _ref; } + public void setReference(String ref) { _ref = ref; } + + public boolean isRequired() { return _required; } + public void setRequired(boolean required) { _required = required; } + + public String getType() { return _type; } + public void setType(String type) { _type = type; } + + public Class getTypeClass() { return _type_class; } + public void setTypeClass(Class type_class) { _type_class = type_class; } + + public String getPattern() { return _pattern; } + public void setPattern(String pattern) { _pattern = pattern; } + + public Pattern getPatternRegexp() { return _pattern_regexp; } + public void setPatternRegexp(Pattern patternRegexp) { _pattern_regexp = patternRegexp; } + + public List getEnum() { return _enum; } + public void setEnum(List enumList) { _enum = enumList; } + + public List getSequence() { return _sequence; } + public void setSequence(List sequence) { _sequence = sequence; } + + public DefaultableHashMap getMapping() { return _mapping; } + public void setMapping(DefaultableHashMap mapping) { _mapping = mapping; } + + public String getAssert() { return _assert; } + public void setAssert(String assertString) { _assert = assertString; } + + public Map getRange() { return _range; } + public void setRange(Map range) { _range = range; } + + public Map getLength() { return _length; } + public void setLength(Map length) { _length = length; } + + public boolean isIdent() { return _ident; } + public void setIdent(boolean ident) { _ident = ident; } + + public boolean isUnique() { return _unique; } + public void setUnique(boolean unique) { _unique = unique; } + + + /* + * constructors + */ + + public Rule(Object schema, Rule parent) throws SchemaException { + if (schema != null) { + if (! (schema instanceof Map)) { + throw schemaError("schema.notmap", null, "/", null, null); + } + Map rule_table = new IdentityHashMap(); + init((Map)schema, "", rule_table); + } + _parent = parent; + } + + public Rule(Object schema) throws SchemaException { + this(schema, null); + } + + public Rule(Map schema, Rule parent) throws SchemaException { + if (schema != null) { + Map rule_table = new IdentityHashMap(); + init(schema, "", rule_table); + } + _parent = parent; + } + + public Rule(Map schema) throws SchemaException { + this(schema, null); + } + + public Rule() throws SchemaException { + this(null, null); + } + + /* + * constants + */ + + private static final int CODE_NAME = "name".hashCode(); + private static final int CODE_DESC = "desc".hashCode(); + private static final int CODE_SHORT = "short".hashCode(); //jora + private static final int CODE_RULE = "rule".hashCode(); //jora + private static final int CODE_REQUIRED = "required".hashCode(); + private static final int CODE_TYPE = "type".hashCode(); + private static final int CODE_PATTERN = "pattern".hashCode(); + private static final int CODE_ENUM = "enum".hashCode(); + private static final int CODE_SEQUENCE = "sequence".hashCode(); + private static final int CODE_MAPPING = "mapping".hashCode(); + private static final int CODE_ASSERT = "assert".hashCode(); + private static final int CODE_RANGE = "range".hashCode(); + private static final int CODE_LENGTH = "length".hashCode(); + private static final int CODE_IDENT = "ident".hashCode(); + private static final int CODE_UNIQUE = "unique".hashCode(); + + + + /* + * instance methods + */ + public Rule getParent() { // by jora + return this._parent; + } + + + private static SchemaException schemaError(String errorSymbol, Rule rule, String path, Object value, Object[] args) { + String msg = Messages.buildMessage(errorSymbol, value, args); + return new SchemaException(msg, path, value, rule, errorSymbol); + } + + + private void init(Object elem, String path, Map rule_table) throws SchemaException { + assert elem != null; + if (! (elem instanceof Map)) { + if (path == null || path.equals("")) { + path = "/"; + } + throw schemaError("schema.notmap", null, path, null, null); + } + init((Map)elem, path, rule_table); + + } + + + private void init(Map hash, String path, Map rule_table) throws SchemaException { + Rule rule = this; + rule_table.put(hash, rule); + + // 'type:' entry + Object type = hash.get("type"); + initTypeValue(type, rule, path); + + // other entries + for (Iterator it = hash.keySet().iterator(); it.hasNext(); ) { + Object key = it.next(); + Object value = hash.get(key); + int code = key.hashCode(); + + if (code == CODE_TYPE && key.equals("type")) { + // done + } else if (code == CODE_NAME && key.equals("name")) { + initNameValue(value, rule, path); + } else if (code == CODE_DESC && key.equals("desc")) { + initDescValue(value, rule, path); + } else if (code == CODE_SHORT && key.equals("short")) { + initShortValue(value, rule, path); + } else if (code == CODE_REQUIRED && key.equals("required")) { + initRequiredValue(value, rule, path); + } else if (code == CODE_PATTERN && key.equals("pattern")) { + initPatternValue(value, rule, path); + } else if (code == CODE_ENUM && key.equals("enum")) { + initEnumValue(value, rule, path); + } else if (code == CODE_ASSERT && key.equals("assert")) { + initAssertValue(value, rule, path); + } else if (code == CODE_RANGE && key.equals("range")) { + initRangeValue(value, rule, path); + } else if (code == CODE_LENGTH && key.equals("length")) { + initLengthValue(value, rule, path); + } else if (code == CODE_IDENT && key.equals("ident")) { + initIdentValue(value, rule, path); + } else if (code == CODE_UNIQUE && key.equals("unique")) { + initUniqueValue(value, rule, path); + } else if (code == CODE_SEQUENCE && key.equals("sequence")) { + rule = initSequenceValue(value, rule, path, rule_table); + } else if (code == CODE_MAPPING && key.equals("mapping")) { + rule = initMappingValue(value, rule, path, rule_table); + } else if (code == CODE_RULE && key.equals("rule")) { + rule = initReferenceValue(value, rule, path, rule_table); + } else { + // removed by 'jora': interferes with the usage of YAML anchor/alias in grammar files + // throw schemaError("key.unknown", rule, path + "/" + key, key.toString() + ":", null); + } + } + + // confliction check + checkConfliction(hash, rule, path); + } + + + private void initTypeValue(Object value, Rule rule, String path) throws SchemaException { + if (value == null) { + value = Types.getDefaultType(); + } + if (! (value instanceof String)) { + throw schemaError("type.notstr", rule, path + "/type", _type, null); + } + _type = (String)value; + _type_class = Types.typeClass(_type); + if (! Types.isBuiltinType(_type)) { + throw schemaError("type.unknown", rule, path + "/type", _type, null); + } + } + + + private void initNameValue(Object value, Rule rule, String path) throws SchemaException { + _name = value.toString(); + } + + + private void initDescValue(Object value, Rule rule, String path) throws SchemaException { + _desc = value.toString(); + } + + private void initShortValue(Object value, Rule rule, String path) throws SchemaException { + + //the short form specification is to be interpreted as key if the type is a map or as an + //index if the target is a sequence (as index 0 actually) + if (!Types.isCollectionType(_type)) { + throw schemaError("range.notcollection", rule, path + "/short", value, null); + } + //we should also verify that it points to a declared key of the mapping .. not really, as it would + //fail the overall grammar + _short = value.toString(); + } + + private void initRequiredValue(Object value, Rule rule, String path) throws SchemaException { + if (! (value instanceof Boolean)) { + throw schemaError("required.notbool", rule, path + "/required", value, null); + } + _required = ((Boolean)value).booleanValue(); + } + + + private void initPatternValue(Object value, Rule rule, String path) throws SchemaException { + if (! (value instanceof String)) { + throw schemaError("pattern.notstr", rule, path + "/pattern", value, null); + } + _pattern = (String)value; + Matcher m = Util.matcher(_pattern, "\\A/(.*)/([mi]?[mi]?)\\z"); + if (! m.find()) { + throw schemaError("pattern.notmatch", rule, path + "/pattern", value, null); + } + String pat = m.group(1); + String opt = m.group(2); + int flag = 0; + if (opt.indexOf('i') >= 0) { + flag += Pattern.CASE_INSENSITIVE; + } + if (opt.indexOf('m') >= 0) { + flag += Pattern.DOTALL; // not MULTILINE + } + try { + _pattern_regexp = Pattern.compile(pat, flag); + } catch (PatternSyntaxException ex) { + throw schemaError("pattern.syntaxerr", rule, path + "/pattern", value, null); + } + } + + + private void initEnumValue(Object value, Rule rule, String path) throws SchemaException { + if (! (value instanceof List)) { + throw schemaError("enum.notseq", rule, path + "/enum", value, null); + } + _enum = (List)value; + if (Types.isCollectionType(_type)) { + throw schemaError("enum.notscalar", rule, path, "enum:", null); + } + Map elem_table = new HashMap(); + for (Iterator it = _enum.iterator(); it.hasNext(); ) { + Object elem = it.next(); + if (! Util.isInstanceOf(elem, _type_class)) { + throw schemaError("enum.type.unmatch", rule, path + "/enum", elem, new Object[] { Types.typeName(_type) }); + } + if (elem_table.containsKey(elem)) { + throw schemaError("enum.duplicate", rule, path + "/enum", elem, null); + } + elem_table.put(elem, Boolean.TRUE); + } + } + + + private void initAssertValue(Object value, Rule rule, String path) throws SchemaException { + if (! (value instanceof String)) { + throw schemaError("assert.notstr", rule, path + "/assert", value, null); + } + _assert = (String)value; + if (! Util.matches(_assert, "\\bval\\b")) { + throw schemaError("assert.noval", rule, path + "/assert", value, null); + } + } + + + private void initRangeValue(Object value, Rule rule, String path) throws SchemaException { + if (! (value instanceof Map)) { + throw schemaError("range.notmap", rule, path + "/range", value, null); + } + if (Types.isCollectionType(_type) || _type.equals("bool")) { + throw schemaError("range.notscalar", rule, path, "range:", null); + } + _range = (Map)value; + for (Iterator it = _range.keySet().iterator(); it.hasNext(); ) { + Object rkey = it.next(); + Object rval = _range.get(rkey); + if (rkey.equals("max") || rkey.equals("min") || rkey.equals("max-ex") || rkey.equals("min-ex")) { + if (! Util.isInstanceOf(rval, _type_class)) { + String typename = Types.typeName(_type); + throw schemaError("range.type.unmatch", rule, path + "/range/" + rkey, rval, new Object[] { typename }); + } + } else { + throw schemaError("range.undefined", rule, path + "/range/" + rkey, rkey.toString() + ":", null); + } + } + if (_range.containsKey("max") && _range.containsKey("max-ex")) { + throw schemaError("range.twomax", rule, path + "/range", null, null); + } + if (_range.containsKey("min") && _range.containsKey("min-ex")) { + throw schemaError("range.twomin", rule, path + "/range", null, null); + } + // + Object max = _range.get("max"); + Object min = _range.get("min"); + Object max_ex = _range.get("max-ex"); + Object min_ex = _range.get("min-ex"); + Object[] args = null; + //String error_symbol = null; + if (max != null) { + if (min != null && Util.compareValues(max, min) < 0) { + args = new Object[] { max, min }; + throw schemaError("range.maxltmin", rule, path + "/range", null, args); + } else if (min_ex != null && Util.compareValues(max, min_ex) <= 0) { + args = new Object[] { max, min_ex }; + throw schemaError("range.maxleminex", rule, path + "/range", null, args); + } + } else if (max_ex != null) { + if (min != null && Util.compareValues(max_ex, min) <= 0) { + args = new Object[] { max_ex, min }; + throw schemaError("range.maxexlemin", rule, path + "/range", null, args); + } else if (min_ex != null && Util.compareValues(max_ex, min_ex) <= 0) { + args = new Object[] { max_ex, min_ex }; + throw schemaError("range.maxexleminex", rule, path + "/range", null, args); + } + } + } + + + private void initLengthValue(Object value, Rule rule, String path) throws SchemaException { + if (! (value instanceof Map)) { + throw schemaError("length.notmap", rule, path + "/length", value, null); + } + _length = (Map)value; + if (! (_type.equals("str") || _type.equals("text"))) { + throw schemaError("length.nottext", rule, path, "length:", null); + } + for (Iterator it = _length.keySet().iterator(); it.hasNext(); ) { + Object k = it.next(); + Object v = _length.get(k); + if (k.equals("max") || k.equals("min") || k.equals("max-ex") || k.equals("min-ex")) { + if (! (v instanceof Integer)) { + throw schemaError("length.notint", rule, path + "/length/" + k, v, null); + } + } else { + throw schemaError("length.undefined", rule, path + "/length/" + k, k + ":", null); + } + } + if (_length.containsKey("max") && _length.containsKey("max-ex")) { + throw schemaError("length.twomax", rule, path + "/length", null, null); + } + if (_length.containsKey("min") && _length.containsKey("min-ex")) { + throw schemaError("length.twomin", rule, path + "/length", null, null); + } + // + Integer max = (Integer)_length.get("max"); + Integer min = (Integer)_length.get("min"); + Integer max_ex = (Integer)_length.get("max-ex"); + Integer min_ex = (Integer)_length.get("min-ex"); + Object[] args = null; + //String error_symbol = null; + if (max != null) { + if (min != null && max.compareTo(min) < 0) { + args = new Object[] { max, min }; + throw schemaError("length.maxltmin", rule, path + "/length", null, args); + } else if (min_ex != null && max.compareTo(min_ex) <= 0) { + args = new Object[] { max, min_ex }; + throw schemaError("length.maxleminex", rule, path + "/length", null, args); + } + } else if (max_ex != null) { + if (min != null && max_ex.compareTo(min) <= 0) { + args = new Object[] { max_ex, min }; + throw schemaError("length.maxexlemin", rule, path + "/length", null, args); + } else if (min_ex != null && max_ex.compareTo(min_ex) <= 0) { + args = new Object[] { max_ex, min_ex }; + throw schemaError("length.maxexleminex", rule, path + "/length", null, args); + } + } + } + + + private void initIdentValue(Object value, Rule rule, String path) throws SchemaException { + if (value == null || ! (value instanceof Boolean)) { + throw schemaError("ident.notbool", rule, path + "/ident", value, null); + } + _ident = ((Boolean)value).booleanValue(); + _required = true; + if (Types.isCollectionType(_type)) { + throw schemaError("ident.notscalar", rule, path, "ident:", null); + } + if (path.equals("")) { + throw schemaError("ident.onroot", rule, "/", "ident:", null); + } + if (_parent == null || ! _parent.getType().equals("map")) { + throw schemaError("ident.notmap", rule, path, "ident:", null); + } + } + + + private void initUniqueValue(Object value, Rule rule, String path) throws SchemaException { + if (! (value instanceof Boolean)) { + throw schemaError("unique.notbool", rule, path + "/unique", value, null); + } + _unique = ((Boolean)value).booleanValue(); + if (Types.isCollectionType(_type)) { + throw schemaError("unique.notscalar", rule, path, "unique:", null); + } + if (path.equals("")) { + throw schemaError("unique.onroot", rule, "/", "unique:", null); + } + //if (_parent == null || _parent.getType() == "map") { + // throw schemaError("sequence.notseq", rule, path + "/unique", value); + //} + } + + + private Rule initSequenceValue(Object value, Rule rule, String path, Map rule_table) throws SchemaException { + if (value != null && ! (value instanceof List)) { + throw schemaError("sequence.notseq", rule, path + "/sequence", value.toString(), null); + } + _sequence = (List)value; + if (_sequence == null || _sequence.size() == 0) { + throw schemaError("sequence.noelem", rule, path + "/sequence", value, null); + } + if (_sequence.size() > 1) { + throw schemaError("sequence.toomany", rule, path + "/sequence", value, null); + } + Object elem = _sequence.get(0); + if (elem == null) { + elem = new HashMap(); + } + int i = 0; + // Rule rule; + rule = (Rule)rule_table.get(elem); + if (rule == null) { + rule = new Rule(null, this); + rule.init(elem, path + "/sequence/" + i, rule_table); + } + _sequence = new ArrayList(); + _sequence.add(rule); + return rule; + } + + + private Rule initMappingValue(Object value, Rule rule, String path, Map rule_table) throws SchemaException { + + // error check + if (value != null && !(value instanceof Map)) { + throw schemaError("mapping.notmap", rule, path + "/mapping", value.toString(), null); + } + Object default_value = null; + if (value instanceof Defaultable) { + default_value = ((Defaultable)value).getDefault(); + } + if (value == null || ((Map)value).size() == 0 && default_value == null) { + throw schemaError("mapping.noelem", rule, path + "/mapping", value, null); + } + // create hash of rule + _mapping = new DefaultableHashMap(); + if (default_value != null) { + rule = (Rule)rule_table.get(default_value); + if (rule == null) { + rule = new Rule(null, this); + rule.init(default_value, path + "/mapping/=", rule_table); + } + _mapping.setDefault(rule); + } + // put rules into _mapping + Map map = (Map)value; + for (Iterator it = map.keySet().iterator(); it.hasNext(); ) { + Object k = it.next(); + Object v = map.get(k); // DefaultableHashMap + if (v == null) { + v = new DefaultableHashMap(); + } + rule = (Rule)rule_table.get(v); + if (rule == null) { + rule = new Rule(null, this); + rule.init(v, path + "/mapping/" + k, rule_table); + } + if (k.equals("=")) { + _mapping.setDefault(rule); + } else { + _mapping.put(k, rule); + } + } + return rule; + } + + private Rule initReferenceValue(Object value, Rule rule, String path, Map rule_table) throws SchemaException { + + this._ref = (String)value; + if (this._ref == null) + throw schemaError("required.novalue", rule, path, "rule", null); + //make sure a rule with this name is in scope + Rule refed = (Rule) + rule_table.values().stream() + .filter(val -> ((Rule)val).getName() != null && ((Rule)val).getName().equals(this._ref)) + .findFirst() + .orElse(null); + if (null == refed) + throw schemaError("ref.nosuchrule", rule, path, "reference", new Object[] { value }); + + return rule; + } + + private void checkConfliction(Map hash, Rule rule, String path) { + if (_type.equals("seq")) { + if (! hash.containsKey("sequence")) throw schemaError("seq.nosequence", rule, path, null, null); + if (_enum != null) throw schemaError("seq.conflict", rule, path, "enum:", null); + if (_pattern != null) throw schemaError("seq.conflict", rule, path, "pattern:", null); + if (_mapping != null) throw schemaError("seq.conflict", rule, path, "mapping:", null); + if (_range != null) throw schemaError("seq.conflict", rule, path, "range:", null); + if (_length != null) throw schemaError("seq.conflict", rule, path, "length:", null); + } else if (_type.equals("map")) { + if (! hash.containsKey("mapping")) throw schemaError("map.nomapping", rule, path, null, null); + if (_enum != null) throw schemaError("map.conflict", rule, path, "enum:", null); + if (_pattern != null) throw schemaError("map.conflict", rule, path, "pattern:", null); + if (_sequence != null) throw schemaError("map.conflict", rule, path, "sequence:", null); + if (_range != null) throw schemaError("map.conflict", rule, path, "range:", null); + if (_length != null) throw schemaError("map.conflict", rule, path, "length:", null); + } else { + if (_sequence != null) throw schemaError("scalar.conflict", rule, path, "sequence:", null); + if (_mapping != null) throw schemaError("scalar.conflict", rule, path, "mapping:", null); + if (_enum != null) { + if (_range != null) throw schemaError("enum.conflict", rule, path, "range:", null); + if (_length != null) throw schemaError("enum.conflict", rule, path, "length:", null); + if (_pattern != null) throw schemaError("enum.conflict", rule, path, "pattern:", null); + } + } + } + + + public String inspect() { + StringBuffer sb = new StringBuffer(); + int level = 0; + Map done = new IdentityHashMap(); + inspect(sb, level, done); + return sb.toString(); + } + + private void inspect(StringBuffer sb, int level, Map done) { + done.put(this, Boolean.TRUE); + String indent = Util.repeatString(" ", level); + if (_name != null) { sb.append(indent).append("name: ").append(_name).append("\n"); } + if (_desc != null) { sb.append(indent).append("desc: ").append(_desc).append("\n"); } + if (_type != null) { sb.append(indent).append("type: ").append(_type).append("\n"); } + if (_required) { sb.append(indent).append("required: ").append(_required).append("\n"); } + if (_pattern != null) { sb.append(indent).append("pattern: ").append(_pattern).append("\n"); } + if (_pattern_regexp != null) { sb.append(indent).append("regexp: ").append(_pattern_regexp).append("\n"); } + if (_assert != null) { sb.append(indent).append("assert: ").append(_assert).append("\n"); } + if (_ident) { sb.append(indent).append("ident: ").append(_ident).append("\n"); } + if (_unique) { sb.append(indent).append("unique: ").append(_unique).append("\n"); } + if (_enum != null) { + sb.append(indent).append("enum:\n"); + for (Iterator it = _enum.iterator(); it.hasNext(); ) { + sb.append(indent).append(" - ").append(it.next().toString()).append("\n"); + } + } + if (_range != null) { + sb.append(indent).append("range: { "); + String[] keys = new String[] { "max", "max-ex", "min", "min-ex", }; + String colon = ""; + for (int i = 0; i < keys.length; i++) { + Object val = _range.get(keys[i]); + if (val != null) { + sb.append(colon).append(keys[i]).append(": ").append(val); + colon = ", "; + } + } + sb.append(" }\n"); + } + if (_sequence != null) { + for (Iterator it = _sequence.iterator(); it.hasNext(); ) { + Rule rule = (Rule)it.next(); + if (done.containsKey(rule)) { + sb.append(indent).append(" ").append("- ...\n"); + } else { + sb.append(indent).append(" ").append("- \n"); + rule.inspect(sb, level + 2, done); + } + } + } + if (_mapping != null) { + for (Iterator it = _mapping.entrySet().iterator(); it.hasNext(); ) { + Map.Entry entry = (Map.Entry)it.next(); + Object key = entry.getKey(); + Rule rule = (Rule)entry.getValue(); + sb.append(indent).append(" ").append(Util.inspect(key)); + if (done.containsKey(rule)) { + sb.append(": ...\n"); + } else { + sb.append(":\n"); + rule.inspect(sb, level + 2, done); + } + } + } + } + +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/SchemaException.java b/javatoscachecker/kwalify/src/main/java/kwalify/SchemaException.java new file mode 100644 index 0000000..5d53bd1 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/SchemaException.java @@ -0,0 +1,22 @@ +/* + * @(#)SchemaException.java $Rev: 4 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +/** + * exception class thrown by Rule constructor + * + * @revision $Rev: 4 $ + * @release $Release: 0.5.1 $ + */ +public class SchemaException extends BaseException { + private static final long serialVersionUID = 4750598728284538818L; + + public SchemaException(String message, String ypath, Object value, Rule rule, String errorSymbol) { + super(message, ypath, value, rule, errorSymbol); + } + +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/SyntaxException.java b/javatoscachecker/kwalify/src/main/java/kwalify/SyntaxException.java new file mode 100644 index 0000000..8c36b66 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/SyntaxException.java @@ -0,0 +1,28 @@ +/* + * @(#)SyntaxException.java $Rev: 4 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +/** + * exception class thrown by parser when syntax is wrong. + * + * @revision $Rev: 4 $ + * @release $Release: 0.5.1 $ + * @see Parser, YamlSyntaxException + */ +public class SyntaxException extends KwalifyException { + private static final long serialVersionUID = 2480059811372002740L; + + private int _linenum; + + public SyntaxException(String message, int linenum) { + super(message); + _linenum = linenum; + } + + public int getLineNumber() { return _linenum; } + public void setLineNumber(int linenum) { _linenum = linenum; } +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/Types.java b/javatoscachecker/kwalify/src/main/java/kwalify/Types.java new file mode 100644 index 0000000..fbe655c --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/Types.java @@ -0,0 +1,107 @@ +/* + * @(#)Types.java $Rev: 4 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +import java.util.Map; +import java.util.HashMap; +import java.util.List; +import java.util.Date; + +/** + * utility methods for type (str, int, ...). + * + * @revision $Rev: 4 $ + * @release $Release: 0.5.1 $ + */ +public class Types { + + public static Class typeClass(String type) { + return (Class)__type_classes.get(type); + } + + public static String typeName(String type) { + String name = (String)__type_names.get(type); + if (name == null) name = type; + return name; + } + + public static final String DEFAULT_TYPE = "str"; + + public static String getDefaultType() { return DEFAULT_TYPE; } + + private static Map __type_classes; + private static Map __type_names; + static { + // + __type_classes = new HashMap(); + __type_classes.put("str", String.class); + __type_classes.put("int", Integer.class); + __type_classes.put("float", Double.class); + __type_classes.put("number", Number.class); + __type_classes.put("text", null); + __type_classes.put("bool", Boolean.class); + __type_classes.put("map", Map.class); + __type_classes.put("seq", List.class); + __type_classes.put("timestamp", Date.class); + __type_classes.put("date", Date.class); + __type_classes.put("symbol", String.class); + __type_classes.put("scalar", null); + __type_classes.put("any", Object.class); + __type_classes.put("ref", Object.class); // by jora + //__type_classes.put("null", null); + + // + __type_names = new HashMap(); + __type_names.put("map", "mapping"); + __type_names.put("seq", "sequence"); + __type_names.put("str", "string"); + __type_names.put("int", "integer"); + __type_names.put("bool", "boolean"); + __type_names.put("ref", "reference"); //by jora + } + + + public static boolean isBuiltinType(String type) { + return __type_classes.containsKey(type); + } + + public static boolean isCollectionType(String type) { + return type.equals("map") || type.equals("seq"); + } + + public static boolean isMapType(String type) { + return type.equals("map"); + } + + public static boolean isScalarType(String type) { + return !isCollectionType(type); + } + + public static boolean isCollection(Object obj) { + return obj instanceof Map || obj instanceof List; + } + + public static boolean isScalar(Object obj) { + return !isCollection(obj); + } + + public static boolean isCorrectType(Object obj, String type) { + Class type_class = typeClass(type); + if (type_class != null) { + return type_class.isInstance(obj); + } + if (type.equals("null")) { + return obj == null; + } else if (type.equals("text")) { + return obj instanceof String || obj instanceof Number; + } else if (type.equals("scalar")) { + return obj instanceof Number || obj instanceof String || obj instanceof Boolean || obj instanceof Date; + } + return false; + } + +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/Util.java b/javatoscachecker/kwalify/src/main/java/kwalify/Util.java new file mode 100644 index 0000000..c27c947 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/Util.java @@ -0,0 +1,646 @@ +/* + * @(#)Util.java $Rev: 4 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +import java.util.Collections; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; +import java.util.IdentityHashMap; +import java.util.Iterator; +import java.util.regex.Pattern; +import java.util.regex.Matcher; +import java.util.Date; +import java.io.Reader; +import java.io.InputStreamReader; +import java.io.InputStream; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.Writer; +import java.io.FileWriter; +import java.io.File; + + +/** + * set of utility methods + * + * @revision $Rev: 4 $ + * @release $Release: 0.5.1 $ + */ + +public class Util { + + /** + * inspect List or Map + */ + public static String inspect(Object obj) { + StringBuffer sb = new StringBuffer(); + inspect(obj, sb, null); + return sb.toString(); + } + + private static void inspect(Object obj, StringBuffer sb, Map done) { + if (obj == null) { + sb.append("nil"); // null? + } else if (obj instanceof String) { + inspect((String)obj, sb, done); + } else if (obj instanceof Map) { + if (done == null) { + done = new IdentityHashMap(); + } + if (done.containsKey(obj)) { + sb.append("{...}"); + } else { + done.put(obj, Boolean.TRUE); + inspect((Map)obj, sb, done); + } + } else if (obj instanceof List) { + if (done == null) { + done = new IdentityHashMap(); + } + if (done.containsKey(obj)) { + sb.append("[...]"); + } else { + done.put(obj, Boolean.TRUE); + inspect((List)obj, sb, done); + } + } else { + sb.append(obj.toString()); + } + } + + private static void inspect(Map map, StringBuffer sb, Map done) { + sb.append('{'); + List list = new ArrayList(map.keySet()); + Collections.sort(list); + int i = 0; + for (Iterator it = list.iterator(); it.hasNext(); i++) { + Object key = it.next(); + Object value = map.get(key); + if (i > 0) { + sb.append(", "); + } + inspect(key, sb, done); + sb.append("=>"); + inspect(value, sb, done); + } + sb.append('}'); + } + + private static void inspect(List list, StringBuffer sb, Map done) { + sb.append('['); + int i = 0; + for (Iterator it = list.iterator(); it.hasNext(); i++) { + if (i > 0) { + sb.append(", "); + } + Object item = it.next(); + inspect(item, sb, null); + } + sb.append(']'); + } + + private static void inspect(String str, StringBuffer sb, Map done) { + sb.append('"'); + for (int i = 0; i < str.length(); i++) { + char ch = str.charAt(i); + switch (ch) { + case '"': sb.append("\\\""); break; + case '\n': sb.append("\\n"); break; + case '\r': sb.append("\\r"); break; + case '\t': sb.append("\\t"); break; + default: sb.append(ch); break; + } + } + sb.append('"'); + } + + + + /** + * + */ + protected static HashMap __patterns = new HashMap(); + + /** + * match pattern and return Mather object. + * + * ex. + * <pre> + * String target = " name = foo\n mail = foo@mail.com\m"; + * Matcher m = Util.matcher(target, "^\\s*(\\w+)\\s*=\\s*(.*)$"); + * while (m.find()) { + * String key = m.group(1); + * String value = m.gropu(2); + * } + * </pre> + */ + public static Matcher matcher(String target, String regexp) { + Pattern pat = (Pattern)__patterns.get(regexp); + if (pat == null) { + pat = Pattern.compile(regexp); + __patterns.put(regexp, pat); + } + return pat.matcher(target); + } + + + public static Matcher matcher(String target, Pattern regexp) { + return regexp.matcher(target); + } + + + /** + * return if pattern matched or not. + * + * ex. + * <pre> + * String target = " name = foo\n"; + * if (Util.matches(target, "^\\s*(\\w+)\\s*=\\s*(.*)$")) { + * System.out.println("matched."); + * } + * </pre> + */ + public static boolean matches(String target, String regexp) { + Matcher m = matcher(target, regexp); + return m.find(); + } + + + public static boolean matches(String target, Pattern regexp) { + Matcher m = regexp.matcher(target); + return m.find(); + } + + + /** + * shift array and return new array shifted + */ + public static String[] arrayShift(String[] array) { + String[] new_array = new String[array.length - 1]; + for (int i = 0; i < new_array.length; i++) { + new_array[i] = array[i + 1]; + } + return new_array; + } + + + /** + * pop up array an dreturn new array popped + */ + public static String[] arrayPop(String[] array) { + String[] new_array = new String[array.length - 1]; + for (int i = 0; i < new_array.length; i++) { + new_array[i] = array[i]; + } + return new_array; + } + + + /** + * concatenate all elements of array with separator + */ + public static String join(Object[] array, String separator) { + StringBuffer sb = new StringBuffer(); + for (int i = 0; i < array.length; i++) { + if (i > 0) { + sb.append(separator); + } + sb.append(array[i]); + } + return sb.toString(); + } + + + /** + * concatenate all elements of list with separator + */ + public static String join(List list, String separator) { + StringBuffer sb = new StringBuffer(); + int i = 0; + for (Iterator it = list.iterator(); it.hasNext(); i++) { + Object item = it.next(); + if (i > 0) { + sb.append(separator); + } + sb.append(item); + } + return sb.toString(); + } + + + /** + * split string into list of line + */ + public static List toListOfLines(String str) { + List list = new ArrayList(); + int len = str.length(); + int head = 0; + for (int i = 0; i < len; i++) { + char ch = str.charAt(i); + if (ch == '\n') { + int tail = i + 1; + String line = str.substring(head, tail); + list.add(line); + head = tail; + } + } + if (head != len) { + String line = str.substring(head, len); + list.add(line); + } + return list; + } + + + /** + * split string into array of line + */ + public static String[] toLines(String str) { + List list = toListOfLines(str); + String[] lines = new String[list.size()]; + list.toArray(lines); + return lines; + } + + + /** + * return object id + */ + public static Integer getId(Object obj) { + int id = System.identityHashCode(obj); + return new Integer(id); + } + + + /** + * return true if 'instance' is an instance of 'klass' + */ + public static boolean isInstanceOf(Object instance, Class klass) { + if (instance == null || klass == null) { + return false; + } + Class c = instance.getClass(); + if (klass.isInterface()) { + while (c != null) { + Class[] interfaces = c.getInterfaces(); + for (int i = 0; i < interfaces.length; i++) { + if (interfaces[i] == klass) { + return true; + } + } + c = c.getSuperclass(); + } + } else { + while (c != null) { + if (c == klass) { + return true; + } + c = c.getSuperclass(); + } + } + return false; + } + + + /** + * read file content with default encoding of system + */ + public static String readFile(String filename) throws IOException { + String charset = System.getProperty("file.encoding"); + return readFile(filename, charset); + } + + + /** + * read file content with specified encoding + */ + public static String readFile(String filename, String encoding) throws IOException { + InputStream stream = null; + String content = null; + try { + stream = new FileInputStream(filename); + content = readInputStream(stream, encoding); + } finally { + if (stream != null) { + try { + stream.close(); + } catch (IOException ignore) {} + } + } + return content; + } + + /** + * + */ + public static String readInputStream(InputStream stream) throws IOException { + String encoding = System.getProperty("file.encoding"); + return readInputStream(stream, encoding); + } + + + /** + * + */ + public static String readInputStream(InputStream stream, String encoding) throws IOException { + Reader reader = null; + String content = null; + try { + reader = new InputStreamReader(stream, encoding); + StringBuffer sb = new StringBuffer(); + int ch; + while ((ch = reader.read()) >= 0) { + sb.append((char)ch); + } + content = sb.toString(); + } finally { + if (reader != null) { + try { + reader.close(); + } catch (IOException ignore) {} + } + } + return content; + } + + + /** + * + */ + public static void writeFile(String filename, String content) throws IOException { + Writer writer = null; + try { + writer = new FileWriter(filename); + writer.write(content); + } finally { + if (writer != null) { + writer.close(); + } + } + } + + + public static void makeDir(String path) throws IOException { + File dir = new File(path); + dir.mkdir(); + } + + + public static void renameFile(String old_path, String new_path) throws IOException { + File old_file = new File(old_path); + File new_file = new File(new_path); + new_file.delete(); + old_file.renameTo(new_file); + } + + + public static void moveFile(String filepath, String dirpath) throws IOException { + File old_file = new File(filepath); + File new_file = new File(dirpath + "/" + old_file.getName()); + new_file.delete(); + old_file.renameTo(new_file); + } + + + public static String untabify(CharSequence str) { + return untabify(str, 8); + } + + + public static String untabify(CharSequence str, int tab_width) { + StringBuffer sb = new StringBuffer(); + int len = str.length(); + int col = -1; + for (int i = 0; i < len; i++) { + col = ++col % tab_width; + char ch = str.charAt(i); + //if (ch == '\t') { + // int n = tab_width - col; + // while (--n >= 0) + // sb.append(' '); + // col = -1; // reset col + //} else { + // sb.append(ch); + // if (ch == '\n') + // col = -1; // reset col + //} + switch (ch) { + case '\t': + int n = tab_width - col; + while (--n >= 0) { + sb.append(' '); + } + col = -1; // reset col + break; + case '\n': + sb.append(ch); + col = -1; // reset col; + break; + default: + sb.append(ch); + } + } + return sb.toString(); + } + + + private static final int VALUE_INTEGER = 1; + private static final int VALUE_DOUBLE = 2; + private static final int VALUE_STRING = 4; + private static final int VALUE_BOOLEAN = 8; + private static final int VALUE_DATE = 16; + private static final int VALUE_OBJECT = 32; + + public static int compare(Object value1, Object value2) throws InvalidTypeException { + if (! (value1 instanceof Comparable)) { + throw new InvalidTypeException(value1.toString() + "is not Comparable."); + } + if (! (value2 instanceof Comparable)) { + throw new InvalidTypeException(value2.toString() + "is not Comparable."); + } + return ((Comparable)value1).compareTo((Comparable)value2); + } + + public static int compareValues(Object value1, Object value2) throws InvalidTypeException { + int vtype = (valueType(value1) << 8) | valueType(value2); + switch (vtype) { + case (VALUE_INTEGER << 8) | VALUE_INTEGER : + return ((Integer)value1).compareTo((Integer)value2); + case (VALUE_DOUBLE << 8) | VALUE_DOUBLE : + return ((Double)value1).compareTo((Double)value2); + case (VALUE_STRING << 8) | VALUE_STRING : + return ((String)value1).compareTo((String)value2); + case (VALUE_BOOLEAN << 8) | VALUE_BOOLEAN : + //return ((Boolean)value1).compareTo((Boolean)value2); // J2SDK1.4 doesn't support Boolean#compareTo()! + boolean b1 = ((Boolean)value1).booleanValue(); + boolean b2 = ((Boolean)value2).booleanValue(); + return b1 == b2 ? 0 : (b1 ? 1 : -1); + //if (b1 == b2) return 0; + //if (b1 && !b2) return 1; + //if (!b1 && b2) return -1; + //assert false; + case (VALUE_DATE << 8) | VALUE_DATE : + return ((Date)value1).compareTo((Date)value2); + // + case (VALUE_DOUBLE << 8) | VALUE_INTEGER : + case (VALUE_INTEGER << 8) | VALUE_DOUBLE : + double d1 = ((Number)value1).doubleValue(); + double d2 = ((Number)value2).doubleValue(); + return d1 > d2 ? 1 : (d1 < d2 ? -1 : 0); + } + throw new InvalidTypeException("cannot compare '" + value1.getClass().getName() + "' with '" + value2.getClass().getName()); + } + + private static int valueType(Object value) { + if (value instanceof Integer) return VALUE_INTEGER; + if (value instanceof Double) return VALUE_DOUBLE; + if (value instanceof String) return VALUE_STRING; + if (value instanceof Boolean) return VALUE_BOOLEAN; + if (value instanceof Date) return VALUE_DATE; + return VALUE_OBJECT; + } + + public static String repeatString(String str, int times) { + StringBuffer sb = new StringBuffer(); + for (int i = 0; i < times; i++) { + sb.append(str); + } + return sb.toString(); + } + + + public static String[] subarray(String[] array, int begin, int end) { + if (begin >= end) { + return null; + } + if (end > array.length) { + end = array.length; + } + int size = end - begin; + String[] array2 = new String[size]; + int i, j; + for (i = begin, j = 0; i < end; i++, j++) { + array2[j] = array[i]; + } + return array2; + } + + public static String[] subarray(String[] array, int begin) { + if (begin < 0) { + begin += array.length; + } + return subarray(array, begin, array.length); + } + + + /** + * parse command-line options. + * + * ex. + * <pre> + * public static void main(String[] arg) { + * String singles = "hv"; // options which takes no argument. + * String requireds = "fI"; // options which requires an argument. + * String optionals = "i"; // options which can take optional argument. + * try { + * Object[] ret = parseCommandOptions(args, singles, requireds, optionals); + * Map options = (Map)ret[0]; + * Map properties = (Map)ret[1]; + * String[] filenames = (String[])ret[2]; + * //... + * } catch (CommandOptionException ex) { + * char option = ex.getOption(); + * String error_symbol = ex.getErrorSymbol(); + * Systen.err.println("*** error: " + ex.getMessage()); + * } + * } + * </pre> + * + * @param args command-line strings + * @param singles options which takes no argument + * @param requireds options which requires an argument. + * @param optionals otpions which can take optional argument. + * @return array of options(Map), properties(Map), and filenames(String[]) + */ + public static Object[] parseCommandOptions(String[] args, String singles, String requireds, String optionals) throws CommandOptionException { + Map options = new HashMap(); + Map properties = new HashMap(); + String[] filenames = null; + // + int i; + for (i = 0; i < args.length; i++) { + if (args[i].length() == 0 || args[i].charAt(0) != '-') { + break; + } + String opt = args[i]; + int len = opt.length(); + if (len == 1) { // option '-' means "don't parse arguments!" + i++; + break; + } + assert len > 1; + if (opt.charAt(1) == '-') { // properties (--pname=pvalue) + String pname; + Object pvalue; + int idx = opt.indexOf('='); + if (idx >= 0) { + pname = opt.substring(2, idx); + pvalue = idx + 1 < opt.length() ? opt.substring(idx + 1) : ""; + } else { + pname = opt.substring(2); + pvalue = Boolean.TRUE; + } + properties.put(pname, pvalue); + } else { // command-line options + for (int j = 1; j < len; j++) { + char ch = opt.charAt(j); + String chstr = Character.toString(ch); + if (singles != null && singles.indexOf(ch) >= 0) { + options.put(chstr, Boolean.TRUE); + } else if (requireds != null && requireds.indexOf(ch) >= 0) { + String arg = null; + if (++j < len) { + arg = opt.substring(j); + } else if (++i < args.length) { + arg = args[i]; + } else { + throw new CommandOptionException("-" + ch + ": filename required.", ch, "command.option.noarg"); + } + options.put(chstr, arg); + break; + } else if (optionals != null && optionals.indexOf(ch) >= 0) { + Object arg = null; + if (++j < len) { + arg = opt.substring(j); + } else { + arg = Boolean.TRUE; + } + options.put(chstr, arg); + break; + } else { + throw new CommandOptionException("-" + ch + "invalid option.", ch, "command.option.invalid"); + } + } + } + } + + // filenames + //String[] filenames = i == args.length ? new String[0] : Util.subarray(args, i); + assert i <= args.length; + int n = args.length - i; + filenames = new String[n]; + for (int j = 0; i < args.length; i++, j++) { + filenames[j] = args[i]; + } + + // + return new Object[] { options, properties, filenames }; + } + +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/ValidationException.java b/javatoscachecker/kwalify/src/main/java/kwalify/ValidationException.java new file mode 100644 index 0000000..5723e01 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/ValidationException.java @@ -0,0 +1,26 @@ +/* + * @(#)ValidationException.java $Rev: 4 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +/** + * exception class which represents validation error. + * + * @revision $Rev: 4 $ + * @release $Release: 0.5.1 $ + */ +public class ValidationException extends BaseException { + private static final long serialVersionUID = -2991121377463453973L; + + public ValidationException(String message, String path, Object value, Rule rule, String error_symbol) { + super(message, path, value, rule, error_symbol); + } + + public ValidationException(String message, String path) { + this(message, path, null, null, null); + } + +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/Validator.java b/javatoscachecker/kwalify/src/main/java/kwalify/Validator.java new file mode 100644 index 0000000..1b3dd53 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/Validator.java @@ -0,0 +1,415 @@ +/* + * @(#)Validator.java $Rev: 3 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +import java.util.Map; +import java.util.HashMap; +import java.util.IdentityHashMap; +import java.util.List; +import java.util.LinkedList; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.Collections; + +/** + * validation engine + * + * ex. + * <pre> + * + * // load YAML document + * String str = Util.readFile("document.yaml"); + * YamlParser parser = new YamlParser(str); + * Object document = parser.parse(); + * + * // load schema + * Object schema = YamlUtil.loadFile("schema.yaml"); + * + * // generate validator and validate document + * Validator validator = new Validator(shema); + * List errors = validator.validate(document); + * + * // show errors + * if (errors != null && errors.size() > 0) { + * parser.setErrorsLineNumber(errors); + * java.util.Collections.sort(errors); + * for (Iterator it = errors.iterator(); it.hasNext(); ) { + * ValidationError error = (ValidationError)it.next(); + * int linenum = error.getLineNumber(); + * String path = error.getPath(); + * String mesg = error.getMessage(); + * String s = "- (" + linenum + ") [" + path + "] " + mesg; + * System.err.println(s); + * } + * } + * </pre> + * + * @version $Rev: 3 $ + * @release $Release: 0.5.1 $ + */ +public class Validator { + private Rule _rule; + + public Validator(Map schema) throws SchemaException { + _rule = new Rule(schema); + } + + public Validator(Object schema) throws SchemaException { + _rule = new Rule(schema); + } + + public Rule getRule() { return _rule; } + //public void setRule(Rule rule) { _rule = rule; } + + public List validate(Object value) { + ValidationContext vctx = new ValidationContext(); + _validateRule(value, _rule, vctx); + return vctx.getErrors(); + } + + protected boolean preValidationHook(Object value, Rule rule, ValidationContext context) { + // nothing + return false; + } + + protected void postValidationHook(Object value, Rule rule, ValidationContext context) { + } + + private void _validateRule(Object value, Rule rule, ValidationContext context) { + //why is done necessary? why would one end up having to validate twice the same collection?? + if (Types.isCollection(value)) { + if (context.done(value)) + return; + } + if (rule.isRequired() && value == null) { + Object[] args = new Object[] { Types.typeName(rule.getType()) }; + context.addError("required.novalue", rule, value, args); + return; + } + + if (preValidationHook(value, rule, context)) { + /* a 'higher power says is ok */ + postValidationHook(value, rule, context); + return; + } + + //Class klass = rule.getTypeClass(); + //if (klass != null && value != null && !klass.isInstance(value)) { + + int n = context.errorCount(); + validateRule(value, rule, context); + if (context.errorCount() != n) { + return; + } + // + postValidationHook(value, rule, context); + } + + /* this is the default validation process */ + protected void validateRule(Object value, Rule rule, ValidationContext context) { + + if (value != null && ! Types.isCorrectType(value, rule.getType())) { + Object[] args = new Object[] { Types.typeName(rule.getType()) }; + context.addError("type.unmatch", rule, value, args); + return; + } + // + if (rule.getSequence() != null) { + assert value == null || value instanceof List; + validateSequence((List)value, rule, context); + } else if (rule.getMapping() != null) { + assert value == null || value instanceof Map; + validateMapping((Map)value, rule, context); + } else if (rule.getReference() != null) { + validateReference(value, rule, context); + } else { + validateScalar(value, rule, context); + } + } + + private void validateScalar(Object value, Rule rule, ValidationContext context) { + assert rule.getSequence() == null; + assert rule.getMapping() == null; + if (rule.getAssert() != null) { + //boolean result = evaluate(rule.getAssert()); + //if (! result) { + // errors.add("asset.failed", rule, path, value, new Object[] { rule.getAssert() }); + //} + } + if (rule.getEnum() != null) { + if (! rule.getEnum().contains(value)) { + //if (Util.matches(keyname, "\\A\\d+\\z") keyname = "enum"; + context.addError("enum.notexist", rule, value, new Object[] { context.getPathElement() }); + } + } + // + if (value == null) { + return; + } + // + if (rule.getPattern() != null) { + if (! Util.matches(value.toString(), rule.getPatternRegexp())) { + context.addError("pattern.unmatch", rule, value, new Object[] { rule.getPattern() }); + } + } + if (rule.getRange() != null) { + assert Types.isScalar(value); + Map range = rule.getRange(); + Object v; + if ((v = range.get("max")) != null && Util.compareValues(v, value) < 0) { + context.addError("range.toolarge", rule, value, new Object[] { v.toString() }); + } + if ((v = range.get("min")) != null && Util.compareValues(v, value) > 0) { + context.addError("range.toosmall", rule, value, new Object[] { v.toString() }); + } + if ((v = range.get("max-ex")) != null && Util.compareValues(v, value) <= 0) { + context.addError("range.toolargeex", rule, value, new Object[] { v.toString() }); + } + if ((v = range.get("min-ex")) != null && Util.compareValues(v, value) >= 0) { + context.addError("range.toosmallex", rule, value, new Object[] { v.toString() }); + } + } + if (rule.getLength() != null) { + assert value instanceof String; + Map length = rule.getLength(); + int len = value.toString().length(); + Integer v; + if ((v = (Integer)length.get("max")) != null && v.intValue() < len) { + context.addError("length.toolong", rule, value, new Object[] { new Integer(len), v }); + } + if ((v = (Integer)length.get("min")) != null && v.intValue() > len) { + context.addError("length.tooshort", rule, value, new Object[] { new Integer(len), v }); + } + if ((v = (Integer)length.get("max-ex")) != null && v.intValue() <= len) { + context.addError("length.toolongex", rule, value, new Object[] { new Integer(len), v }); + } + if ((v = (Integer)length.get("min-ex")) != null && v.intValue() >= len) { + context.addError("length.tooshortex", rule, value, new Object[] { new Integer(len), v }); + } + } + } + + + private void validateSequence(List sequence, Rule seq_rule, ValidationContext context) { + assert seq_rule.getSequence() instanceof List; + assert seq_rule.getSequence().size() == 1; + if (sequence == null) { + return; + } + Rule rule = (Rule)seq_rule.getSequence().get(0); + int i = 0; + for (Iterator it = sequence.iterator(); it.hasNext(); i++) { + Object val = it.next(); + context.addPathElement(String.valueOf(i)); + _validateRule(val, rule, context); // validate recursively + context.removePathElement(); + } + if (rule.getType().equals("map")) { + Map mapping = rule.getMapping(); + List unique_keys = new ArrayList(); + for (Iterator it = mapping.keySet().iterator(); it.hasNext(); ) { + Object key = it.next(); + Rule map_rule = (Rule)mapping.get(key); + if (map_rule.isUnique() || map_rule.isIdent()) { + unique_keys.add(key); + } + } + // + if (unique_keys.size() > 0) { + for (Iterator it = unique_keys.iterator(); it.hasNext(); ) { + Object key = it.next(); + Map table = new HashMap(); // val => index + int j = 0; + for (Iterator it2 = sequence.iterator(); it2.hasNext(); j++) { + Map map = (Map)it2.next(); + Object val = map.get(key); + if (val == null) { + continue; + } + if (table.containsKey(val)) { + String path = context.getPath(); + String prev_path = path + "/" + table.get(val) + "/" + key; + context.addPathElement(String.valueOf(j)) + .addPathElement(key.toString()); + context.addError("value.notunique", rule, val, new Object[] { prev_path }); + context.removePathElement() + .removePathElement(); + } else { + table.put(val, new Integer(j)); + } + } + } + } + } else if (rule.isUnique()) { + Map table = new HashMap(); // val => index + int j = 0; + for (Iterator it = sequence.iterator(); it.hasNext(); j++) { + Object val = it.next(); + if (val == null) { + continue; + } + if (table.containsKey(val)) { + String path = context.getPath(); + String prev_path = path + "/" + table.get(val); + context.addPathElement(String.valueOf(j)) + .addError("value.notunique", rule, val, new Object[] { prev_path }) + .removePathElement(); + } else { + table.put(val, new Integer(j)); + } + } + } + } + + + private void validateMapping(Map mapping, Rule map_rule, ValidationContext context) { + assert map_rule.getMapping() instanceof Map; + if (mapping == null) { + return; + } + Map m = map_rule.getMapping(); + for (Iterator it = m.keySet().iterator(); it.hasNext(); ) { + Object key = it.next(); + Rule rule = (Rule)m.get(key); + if (rule.isRequired() && !mapping.containsKey(key)) { + context.addError("required.nokey", rule, mapping, new Object[] { key }); + } + } + for (Iterator it = mapping.keySet().iterator(); it.hasNext(); ) { + Object key = it.next(); + Object val = mapping.get(key); + Rule rule = (Rule)m.get(key); + context.addPathElement(key.toString()); + if (rule == null) { + context.addError("key.undefined", rule, mapping, new Object[] { key.toString() + ":", map_rule.getName() + m.keySet().toString() }); + } else { + _validateRule(val, rule, context); // validate recursively + } + context.removePathElement(); + } + } + + private void validateReference(Object value, Rule ref_rule, ValidationContext context) { + //look only up the rule chain. This is a limitation + Rule refed = ref_rule; + while ((refed = refed.getParent()) != null) { + if (refed.getName() != null && refed.getName().equals(ref_rule.getReference())) { + validateRule(value, refed, context); + return; + } + } + context.addError("ref.nosuchrule", ref_rule, value, new Object[] { ref_rule.getReference() }); + } + + public class ValidationContext { + + private StringBuilder path = new StringBuilder(""); + private List errors = new LinkedList(); + private Map done = new IdentityHashMap(); //completion tracker + + private ValidationContext() { + } + + public String getPath() { + return this.path.toString(); + } + + public Validator getValidator() { + return Validator.this; + } + + public ValidationContext addPathElement(String theElement) { + this.path.append("/") + .append(theElement); + return this; + } + + public String getPathElement() { + int index = this.path.lastIndexOf("/"); + return index >= 0 ? this.path.substring(index + 1) : this.path.toString(); + } + + public ValidationContext removePathElement() { + int index = this.path.lastIndexOf("/"); + if (index >= 0) + this.path.delete(index, this.path.length()); + return this; + } + + protected ValidationContext addError(String error_symbol, Rule rule, Object value, Object[] args) { + addError( + new ValidationException( + Messages.buildMessage(error_symbol, value, args), getPath(), value, rule, error_symbol)); + return this; + } + + protected ValidationContext addError(String error_symbol, Rule rule, String relpath, Object value, Object[] args) { + addError( + new ValidationException( + Messages.buildMessage(error_symbol, value, args), getPath()+"/"+relpath, value, rule, error_symbol)); + return this; + } + + public ValidationContext addError(String message, Rule rule, Object value, Throwable cause) { + addError( + new ValidationException( + message + ((cause == null) ? "" : ", cause " + cause), getPath(), value, rule, "")); + return this; + } + + public ValidationContext addError(ValidationException theError) { + this.errors.add(theError); + return this; + } + + + public List getErrors() { + return Collections.unmodifiableList(this.errors); + } + + public boolean hasErrors() { + return this.errors.isEmpty(); + } + + public int errorCount() { + return this.errors.size(); + } + + private boolean done(Object theTarget) { + if (this.done.get(theTarget) != null) { + return true; + } + this.done.put(theTarget, Boolean.TRUE); + return false; + } + + private boolean isDone(Object theTarget) { + return this.done.get(theTarget) != null; + } + } + +/* + public static void main(String[] args) throws Exception { + Map schema = (Map)YamlUtil.loadFile("schema.yaml"); + Validator validator = new Validator(schema); + String filename = args.length > 0 ? args[0] : "document.yaml"; + Object document = YamlUtil.loadFile(filename); + List errors = validator.validate(document); + if (errors != null && errors.size() > 0) { + for (Iterator it = errors.iterator(); it.hasNext(); ) { + ValidationException error = (ValidationException)it.next(); + //String s = "- [" + error.getPath() + "] " + error.getMessage(); + String s = "- <" + error.getErrorSymbol() + ">[" + error.getPath() + "] " + error.getMessage(); + System.out.println(s); + } + } else { + System.out.println("validtion OK."); + } + } +*/ + +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/YamlParser.java b/javatoscachecker/kwalify/src/main/java/kwalify/YamlParser.java new file mode 100644 index 0000000..fbe351c --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/YamlParser.java @@ -0,0 +1,156 @@ +/* + * @(#)YamlParser.java $Rev: 3 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ +package kwalify; + +import java.util.Map; +import java.util.HashMap; +import java.util.IdentityHashMap; +import java.util.List; +import java.util.ArrayList; +import java.util.Iterator; + +/** + * yaml parser which can keep line number of path. + * + * ex. + * <pre> + * String yaml_str = Util.readFile("document.yaml"); + * YamlParser parser = new YamlParser(yaml_str); + * Object document = parser.parse(); + * </pre> + */ +public class YamlParser extends PlainYamlParser { + private Map _linenums_table = new IdentityHashMap(); // object => sequence or mapping + private int _first_linenum = -1; + private Object _document = null; + + public YamlParser(String yaml_str) { + super(yaml_str); + } + + public Object parse() throws SyntaxException { + _document = super.parse(); + return _document; + } + + protected String getLine() { + String line = super.getLine(); + if (_first_linenum < 0) { + _first_linenum = currentLineNumber(); + } + return line; + } + + + public int getPathLineNumber(String ypath) throws InvalidPathException { + if (_document == null) { + return -1; + } + if (ypath.length() == 0 || ypath.equals("/")) { + return 1; + } + String[] elems = ypath.split("/"); + String last_elem = elems.length > 0 ? elems[elems.length - 1] : null; + int i = ypath.charAt(0) == '/' ? 1 : 0; + int len = elems.length - 1; + Object c = _document; // collection + for ( /* nothing */ ; i < len; i++) { + if (c == null) { + throw new InvalidPathException(ypath); + } else if (c instanceof Map) { + c = ((Map)c).get(elems[i]); + } else if (c instanceof List) { + int index = Integer.parseInt(elems[i]); + if (index < 0 || ((List)c).size() < index) { + throw new InvalidPathException(ypath); + } + c = ((List)c).get(index); + } else { + throw new InvalidPathException(ypath); + } + } + + if (c == null) { + throw new InvalidPathException(ypath); + } + Object linenums = _linenums_table.get(c); // Map or List + int linenum = -1; + if (c instanceof Map) { + assert linenums instanceof Map; + Object d = ((Map)linenums).get(last_elem); + linenum = ((Integer)d).intValue(); + } else if (c instanceof List) { + assert linenums instanceof List; + int index = Integer.parseInt(last_elem); + if (index < 0 || ((List)linenums).size() <= index) { + throw new InvalidPathException(ypath); + } + Object d = ((List)linenums).get(index); + linenum = ((Integer)d).intValue(); + } else { + throw new InvalidPathException(ypath); + } + return linenum; + } + + public void setErrorsLineNumber(List errors) throws InvalidPathException { + for (Iterator it = errors.iterator(); it.hasNext(); ) { + ValidationException ex = (ValidationException)it.next(); + ex.setLineNumber(getPathLineNumber(ex.getPath())); + } + } + + protected List createSequence(int linenum) { + List seq = new ArrayList(); + _linenums_table.put(seq, new ArrayList()); + return seq; + } + + protected void addSequenceValue(List seq, Object value, int linenum) { + seq.add(value); + List linenums = (List)_linenums_table.get(seq); + linenums.add(new Integer(linenum)); + } + + protected void setSequenceValueAt(List seq, int index, Object value, int linenum) { + seq.set(index, value); + List linenums = (List)_linenums_table.get(seq); + linenums.set(index, new Integer(linenum)); + } + + protected Map createMapping(int linenum) { + Map map = super.createMapping(linenum); + _linenums_table.put(map, new HashMap()); + return map; + } + + protected void setMappingValueWith(Map map, Object key, Object value, int linenum) { + map.put(key, value); + Map linenums = (Map)_linenums_table.get(map); + assert linenums != null; + linenums.put(key, new Integer(linenum)); + } + + protected void setMappingDefault(Map map, Object value, int linenum) { + super.setMappingDefault(map, value, linenum); + Map linenums = (Map)_linenums_table.get(map); + linenums.put(new Character('='), new Integer(linenum)); + } + + protected void mergeMapping(Map map, Map map2, int linenum) { + Map linenums = (Map)_linenums_table.get(map); + Map linenums2 = (Map)_linenums_table.get(map2); + assert linenums2 != null; + for (Iterator it = map2.keySet().iterator(); it.hasNext(); ) { + Object key = it.next(); + if (! map.containsKey(key)) { + map.put(key, map2.get(key)); + linenums.put(key, linenums2.get(key)); + } + } + } + +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/YamlSyntaxException.java b/javatoscachecker/kwalify/src/main/java/kwalify/YamlSyntaxException.java new file mode 100644 index 0000000..a8b1011 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/YamlSyntaxException.java @@ -0,0 +1,23 @@ +/* + * @(#)YamlSyntaxException.java $Rev: 4 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +/** + * exception class thrown by YamlParser when syntax of YAML document is wrong + * + * @revision $Rev: 4 $ + * @release $Release: 0.5.1 $ + * @see SyntaxException + */ +public class YamlSyntaxException extends SyntaxException { + private static final long serialVersionUID = 2951669148531823857L; + + public YamlSyntaxException(String message, int linenum) { + super(message, linenum); + } + +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/YamlUtil.java b/javatoscachecker/kwalify/src/main/java/kwalify/YamlUtil.java new file mode 100644 index 0000000..90dc17c --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/YamlUtil.java @@ -0,0 +1,62 @@ +/* + * @(#)YamlUtil.java $Rev: 3 $ $Release: 0.5.1 $ + * + * copyright(c) 2005 kuwata-lab all rights reserved. + */ + +package kwalify; + +import java.io.InputStream; +import java.io.FileInputStream; +import java.io.Reader; +import java.io.InputStreamReader; +import java.io.IOException; + +/** + * utilify class for yaml. + * + * @version $Rev: 3 $ + * @release $Release: 0.5.1 $ + */ +public class YamlUtil { + + public static Object load(String yaml_str) throws SyntaxException { + PlainYamlParser parser = new PlainYamlParser(yaml_str); + Object doc = parser.parse(); + return doc; + } + + public static Object loadFile(String filename, String charset) throws IOException, SyntaxException { + Object doc = null; + InputStream input = null; + Reader reader = null; + try { + input = new FileInputStream(filename); + reader = new InputStreamReader(input, charset); + StringBuffer sb = new StringBuffer(); + int ch; + while ((ch = reader.read()) >= 0) { + sb.append((char)ch); + } + doc = load(sb.toString()); + } finally { + if (reader != null) { + try { + reader.close(); + } catch (Exception ignore) {} + } + if (input != null) { + try { + input.close(); + } catch (Exception ignore) {} + } + } + return doc; + } + + public static Object loadFile(String filename) throws IOException, SyntaxException { + String encoding = System.getProperty("file.encoding"); + return loadFile(filename, encoding); + } + +} diff --git a/javatoscachecker/kwalify/src/main/java/kwalify/messages.properties b/javatoscachecker/kwalify/src/main/java/kwalify/messages.properties new file mode 100644 index 0000000..c4b45c0 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/java/kwalify/messages.properties @@ -0,0 +1,110 @@ +command.help = \ + Usage1: %s [-hvstlE] -f schema.yaml doc.yaml [doc2.yaml ...]\n\ + Usage2: %s [-hvstlE] -m schema.yaml [schema2.yaml ...]\n\ + \ \ -h, --help : help\n\ + \ \ -v : version\n\ + \ \ -s : silent\n\ + \ \ -f schema.yaml : schema definition file\n\ + \ \ -m : meta-validation mode\n\ + \ \ -t : expand tab character automatically\n\ + \ \ -l : show linenumber when errored (experimental)\n\ + \ \ -E : show errors in emacs-style (implies '-l')\n +command.option.noaction = command-line option '-f' or '-m' required. +meta.empty = %s: empty. +meta.valid = %s: ok. +meta.invalid = %s: NG! +schema.empty = %s#%d: empty. +validation.empty = %s#%d: empty. +validation.valid = %s#%d: valid. +validation.invalid = %s#%d: INVALID +command.property.invalid = %s: invalid property. +command.option.noarg = -%s: argument required. +command.option.noschema = -%s: schema filename required. +command.option.invalid = -%s: invalid command option. +schema.notmap = schema definition is not a mapping. +key.unknown = unknown key. +type.notstr = not a string. +type.unknown = unknown type. +required.notbool = not a boolean. +pattern.notstr = not a string (or regexp) +pattern.notmatch = should be '/..../'. +pattern.syntaxerr = has regexp error. +enum.notseq = not a sequence. +enum.notscalar = not available with seq or map. +enum.type.unmatch = %s type expected. +enum.duplicate = duplicated enum value. +assert.notstr = not a string. +assert.noval = 'val' is not used. +assert.syntaxerr = expression syntax error. +range.notmap = not a mapping. +range.notscalar = is available only with scalar type. +range.notcollection = not a collection type. +range.type.unmatch = not a %s. +range.undefined = undefined key. +range.twomax = both 'max' and 'max-ex' are not available at once. +range.twomin = both 'min' and 'min-ex' are not available at once. +range.maxltmin = max '%s' is less than min '%s'. +range.maxleminex = max '%s' is less than or equal to min-ex '%s'. +range.maxexlemin = max-ex '%s' is less than or equal to min '%s'. +range.maxexleminex = max-ex '%s' is less than or equal to min-ex '%s'. +length.notmap = not a mapping. +length.nottext = is available only with string or text. +length.notint = not an integer. +length.undefined = undefined key. +length.twomax = both 'max' and 'max-ex' are not available at once. +length.twomin = both 'min' and 'min-ex' are not available at once. +length.maxltmin = max '%s' is less than min '%s'. +length.maxleminex = max '%s' is less than or equal to min-ex '%s'. +length.maxexlemin = max-ex '%s' is less than or equal to min '%s'. +length.maxexleminex = max-ex '%s' is less than or equal to min-ex '%s'. +ident.notbool = not a boolean. +ident.notscalar = is available only with a scalar type. +ident.onroot = is not available on root element. +ident.notmap = is available only with an element of mapping. +unique.notbool = not a boolean. +unique.notscalar = is available only with a scalar type. +unique.onroot = is not available on root element. +sequence.notseq = not a sequence. +sequence.noelem = required one element. +sequence.toomany = required just one element. +mapping.notmap = not a mapping. +mapping.noelem = required at least one element. +seq.nosequence = type 'seq' requires 'sequence:'. +seq.conflict = not available with sequence. +map.nomapping = type 'map' requires 'mapping:'. +map.conflict = not available with mapping. +scalar.conflict = not available with scalar type. +enum.conflict = not available with 'enum:'. +required.novalue = value required but none. +type.unmatch = not a %s. +assert.failed = assertion expression failed (%s). +enum.notexist = invalid %s value. +pattern.unmatch = not matched to pattern %s. +range.toolarge = too large (> max %s). +range.toosmall = too small (< min %s). +range.toolargeex = too large (>= max %s). +range.toosmallex = too small (<= min %s). +length.toolong = too long (length %d > max %d). +length.tooshort = too short (length %d < min %d). +length.toolongex = too long (length %d >= max %d). +length.tooshortex = too short (length %d <= min %d). +value.notunique = is already used at '%s'. +required.nokey = key '%s:' is required. +key.undefined = key '%s' is undefined. Expecting one of %s. +flow.hastail = flow style sequence is closed but got '%s'. +flow.eof = found EOF when parsing flow style. +flow.noseqitem = sequence item required (or last comma is extra). +flow.seqnotclosed = flow style sequence requires ']'. +flow.mapnoitem = mapping item required (or last comma is extra). +flow.mapnotclosed = flow style mapping requires '}'. +flow.nocolon = ':' expected but got '%s'. +anchor.duplicated = anchor '%s' is already used. +alias.extradata = alias cannot take any data. +anchor.notfound = anchor '%s' not found +sequence.noitem = sequence item is expected. +sequence.badindent = illegal indent of sequence. +mapping.noitem = mapping item is expected. +mapping.badindent = illegal indent of mapping. +collection.notcollection = not a collection +ref.nosuchrule = no rule '%s' in scope + diff --git a/javatoscachecker/kwalify/src/main/resources/kwalify/messages.properties b/javatoscachecker/kwalify/src/main/resources/kwalify/messages.properties new file mode 100644 index 0000000..c4b45c0 --- /dev/null +++ b/javatoscachecker/kwalify/src/main/resources/kwalify/messages.properties @@ -0,0 +1,110 @@ +command.help = \ + Usage1: %s [-hvstlE] -f schema.yaml doc.yaml [doc2.yaml ...]\n\ + Usage2: %s [-hvstlE] -m schema.yaml [schema2.yaml ...]\n\ + \ \ -h, --help : help\n\ + \ \ -v : version\n\ + \ \ -s : silent\n\ + \ \ -f schema.yaml : schema definition file\n\ + \ \ -m : meta-validation mode\n\ + \ \ -t : expand tab character automatically\n\ + \ \ -l : show linenumber when errored (experimental)\n\ + \ \ -E : show errors in emacs-style (implies '-l')\n +command.option.noaction = command-line option '-f' or '-m' required. +meta.empty = %s: empty. +meta.valid = %s: ok. +meta.invalid = %s: NG! +schema.empty = %s#%d: empty. +validation.empty = %s#%d: empty. +validation.valid = %s#%d: valid. +validation.invalid = %s#%d: INVALID +command.property.invalid = %s: invalid property. +command.option.noarg = -%s: argument required. +command.option.noschema = -%s: schema filename required. +command.option.invalid = -%s: invalid command option. +schema.notmap = schema definition is not a mapping. +key.unknown = unknown key. +type.notstr = not a string. +type.unknown = unknown type. +required.notbool = not a boolean. +pattern.notstr = not a string (or regexp) +pattern.notmatch = should be '/..../'. +pattern.syntaxerr = has regexp error. +enum.notseq = not a sequence. +enum.notscalar = not available with seq or map. +enum.type.unmatch = %s type expected. +enum.duplicate = duplicated enum value. +assert.notstr = not a string. +assert.noval = 'val' is not used. +assert.syntaxerr = expression syntax error. +range.notmap = not a mapping. +range.notscalar = is available only with scalar type. +range.notcollection = not a collection type. +range.type.unmatch = not a %s. +range.undefined = undefined key. +range.twomax = both 'max' and 'max-ex' are not available at once. +range.twomin = both 'min' and 'min-ex' are not available at once. +range.maxltmin = max '%s' is less than min '%s'. +range.maxleminex = max '%s' is less than or equal to min-ex '%s'. +range.maxexlemin = max-ex '%s' is less than or equal to min '%s'. +range.maxexleminex = max-ex '%s' is less than or equal to min-ex '%s'. +length.notmap = not a mapping. +length.nottext = is available only with string or text. +length.notint = not an integer. +length.undefined = undefined key. +length.twomax = both 'max' and 'max-ex' are not available at once. +length.twomin = both 'min' and 'min-ex' are not available at once. +length.maxltmin = max '%s' is less than min '%s'. +length.maxleminex = max '%s' is less than or equal to min-ex '%s'. +length.maxexlemin = max-ex '%s' is less than or equal to min '%s'. +length.maxexleminex = max-ex '%s' is less than or equal to min-ex '%s'. +ident.notbool = not a boolean. +ident.notscalar = is available only with a scalar type. +ident.onroot = is not available on root element. +ident.notmap = is available only with an element of mapping. +unique.notbool = not a boolean. +unique.notscalar = is available only with a scalar type. +unique.onroot = is not available on root element. +sequence.notseq = not a sequence. +sequence.noelem = required one element. +sequence.toomany = required just one element. +mapping.notmap = not a mapping. +mapping.noelem = required at least one element. +seq.nosequence = type 'seq' requires 'sequence:'. +seq.conflict = not available with sequence. +map.nomapping = type 'map' requires 'mapping:'. +map.conflict = not available with mapping. +scalar.conflict = not available with scalar type. +enum.conflict = not available with 'enum:'. +required.novalue = value required but none. +type.unmatch = not a %s. +assert.failed = assertion expression failed (%s). +enum.notexist = invalid %s value. +pattern.unmatch = not matched to pattern %s. +range.toolarge = too large (> max %s). +range.toosmall = too small (< min %s). +range.toolargeex = too large (>= max %s). +range.toosmallex = too small (<= min %s). +length.toolong = too long (length %d > max %d). +length.tooshort = too short (length %d < min %d). +length.toolongex = too long (length %d >= max %d). +length.tooshortex = too short (length %d <= min %d). +value.notunique = is already used at '%s'. +required.nokey = key '%s:' is required. +key.undefined = key '%s' is undefined. Expecting one of %s. +flow.hastail = flow style sequence is closed but got '%s'. +flow.eof = found EOF when parsing flow style. +flow.noseqitem = sequence item required (or last comma is extra). +flow.seqnotclosed = flow style sequence requires ']'. +flow.mapnoitem = mapping item required (or last comma is extra). +flow.mapnotclosed = flow style mapping requires '}'. +flow.nocolon = ':' expected but got '%s'. +anchor.duplicated = anchor '%s' is already used. +alias.extradata = alias cannot take any data. +anchor.notfound = anchor '%s' not found +sequence.noitem = sequence item is expected. +sequence.badindent = illegal indent of sequence. +mapping.noitem = mapping item is expected. +mapping.badindent = illegal indent of mapping. +collection.notcollection = not a collection +ref.nosuchrule = no rule '%s' in scope + |