nokogiri 1.12.4-java → 1.13.2-java

data/ext/java/nokogiri/XmlSaxParserContext.java

@@ -1,33 +1,23 @@
 package nokogiri;
 
-import static org.jruby.runtime.Helpers.invoke;
-
-import java.io.IOException;
-import java.io.InputStream;
-
+import nokogiri.internals.*;
 import org.apache.xerces.parsers.AbstractSAXParser;
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.RubyFixnum;
-import org.jruby.RubyModule;
-import org.jruby.RubyObjectAdapter;
 import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
-import org.jruby.javasupport.JavaEmbedUtils;
+import org.jruby.runtime.Helpers;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
-import org.xml.sax.ContentHandler;
-import org.xml.sax.ErrorHandler;
 import org.xml.sax.SAXException;
-import org.xml.sax.SAXNotRecognizedException;
-import org.xml.sax.SAXNotSupportedException;
 import org.xml.sax.SAXParseException;
 
-import nokogiri.internals.NokogiriHandler;
-import nokogiri.internals.NokogiriHelpers;
-import nokogiri.internals.ParserContext;
-import nokogiri.internals.XmlSaxParser;
+import java.io.IOException;
+import java.io.InputStream;
+
+import static org.jruby.runtime.Helpers.invoke;
 
 /**
  * Base class for the SAX parsers.
@@ -51,6 +41,7 @@ public class XmlSaxParserContext extends ParserContext
   protected AbstractSAXParser parser;
 
   protected NokogiriHandler handler;
+  protected NokogiriErrorHandler errorHandler;
   private boolean replaceEntities = true;
   private boolean recovery = false;
 
@@ -168,31 +159,12 @@ public class XmlSaxParserContext extends ParserContext
     return (XmlSaxParserContext) NokogiriService.XML_SAXPARSER_CONTEXT_ALLOCATOR.allocate(runtime, klazz);
   }
 
-  /**
-   * Set a property of the underlying parser.
-   */
-  protected void
-  setProperty(String key, Object val)
-  throws SAXNotRecognizedException, SAXNotSupportedException
-  {
-    parser.setProperty(key, val);
-  }
-
-  protected void
-  setContentHandler(ContentHandler handler)
-  {
-    parser.setContentHandler(handler);
-  }
-
-  protected void
-  setErrorHandler(ErrorHandler handler)
-  {
-    parser.setErrorHandler(handler);
-  }
-
   public final NokogiriHandler
   getNokogiriHandler() { return handler; }
 
+  public final NokogiriErrorHandler
+  getNokogiriErrorHandler() { return errorHandler; }
+
   /**
    * Perform any initialization prior to parsing with the handler
    * <code>handlerRuby</code>. Convenience hook for subclasses.
@@ -223,6 +195,17 @@ public class XmlSaxParserContext extends ParserContext
     parser.parse(getInputSource());
   }
 
+  protected static Options
+  defaultParseOptions(ThreadContext context)
+  {
+    return new ParserContext.Options(
+             RubyFixnum.fix2long(Helpers.invoke(context,
+                                 ((RubyClass)context.getRuntime().getClassFromPath("Nokogiri::XML::ParseOptions"))
+                                 .getConstant("DEFAULT_XML"),
+                                 "to_i"))
+           );
+  }
+
   @JRubyMethod
   public IRubyObject
   parse_with(ThreadContext context, IRubyObject handlerRuby)
@@ -233,14 +216,19 @@ public class XmlSaxParserContext extends ParserContext
       throw runtime.newArgumentError("argument must respond_to document");
     }
 
-    NokogiriHandler handler = this.handler = new NokogiriHandler(runtime, handlerRuby);
-    preParse(runtime, handlerRuby, handler);
+    /* TODO: how should we pass in parse options? */
+    ParserContext.Options options = defaultParseOptions(context);
+
+    errorHandler = new NokogiriStrictErrorHandler(runtime, options.noError, options.noWarning);
+    handler = new NokogiriHandler(runtime, handlerRuby, errorHandler);
 
-    setContentHandler(handler);
-    setErrorHandler(handler);
+    preParse(runtime, handlerRuby, handler);
+    parser.setContentHandler(handler);
+    parser.setErrorHandler(handler);
+    parser.setEntityResolver(new NokogiriEntityResolver(runtime, errorHandler, options));
 
     try {
-      setProperty("http://xml.org/sax/properties/lexical-handler", handler);
+      parser.setProperty("http://xml.org/sax/properties/lexical-handler", handler);
     } catch (Exception ex) {
       throw runtime.newRuntimeError("Problem while creating XML SAX Parser: " + ex.toString());
     }
@@ -270,8 +258,6 @@ public class XmlSaxParserContext extends ParserContext
 
     postParse(runtime, handlerRuby, handler);
 
-    //maybeTrimLeadingAndTrailingWhitespace(context, handlerRuby);
-
     return runtime.getNil();
   }
 
@@ -319,53 +305,6 @@ public class XmlSaxParserContext extends ParserContext
     return context.runtime.newBoolean(recovery);
   }
 
-  /**
-   * If the handler's document is a FragmentHandler, attempt to trim
-   * leading and trailing whitespace.
-   *
-   * This is a bit hackish and depends heavily on the internals of
-   * FragmentHandler.
-   */
-  protected void
-  maybeTrimLeadingAndTrailingWhitespace(ThreadContext context, IRubyObject parser)
-  {
-    RubyObjectAdapter adapter = JavaEmbedUtils.newObjectAdapter();
-    RubyModule mod = context.getRuntime().getClassFromPath("Nokogiri::XML::FragmentHandler");
-
-    IRubyObject handler = adapter.getInstanceVariable(parser, "@document");
-    if (handler == null || handler.isNil() || !adapter.isKindOf(handler, mod)) {
-      return;
-    }
-    IRubyObject stack = adapter.getInstanceVariable(handler, "@stack");
-    if (stack == null || stack.isNil()) {
-      return;
-    }
-    // doc is finally a DocumentFragment whose nodes we can check
-    IRubyObject doc = adapter.callMethod(stack, "first");
-    if (doc == null || doc.isNil()) {
-      return;
-    }
-
-    IRubyObject children;
-
-    for (;;) {
-      children = adapter.callMethod(doc, "children");
-      IRubyObject first = adapter.callMethod(children, "first");
-      if (NokogiriHelpers.isBlank(first)) { adapter.callMethod(first, "unlink"); }
-      else { break; }
-    }
-
-    for (;;) {
-      children = adapter.callMethod(doc, "children");
-      IRubyObject last = adapter.callMethod(children, "last");
-      if (NokogiriHelpers.isBlank(last)) { adapter.callMethod(last, "unlink"); }
-      else { break; }
-    }
-
-    // While we have a document, normalize it.
-    ((XmlNode) doc).normalize();
-  }
-
   @JRubyMethod(name = "column")
   public IRubyObject
   column(ThreadContext context)
@@ -383,5 +322,4 @@ public class XmlSaxParserContext extends ParserContext
     if (number == null) { return context.getRuntime().getNil(); }
     return RubyFixnum.newFixnum(context.getRuntime(), number.longValue());
   }
-
 }

data/ext/java/nokogiri/XmlSaxPushParser.java

@@ -1,20 +1,9 @@
 package nokogiri;
 
-import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
-import static org.jruby.runtime.Helpers.invoke;
-
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-import java.util.concurrent.FutureTask;
-import java.util.concurrent.ThreadFactory;
-
+import nokogiri.internals.*;
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
+import org.jruby.RubyException;
 import org.jruby.RubyObject;
 import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
@@ -22,11 +11,14 @@ import org.jruby.exceptions.RaiseException;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
-import nokogiri.internals.ClosedStreamException;
-import nokogiri.internals.NokogiriBlockingQueueInputStream;
-import nokogiri.internals.NokogiriHandler;
-import nokogiri.internals.NokogiriHelpers;
-import nokogiri.internals.ParserContext;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.concurrent.*;
+
+import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
+import static org.jruby.runtime.Helpers.invoke;
 
 /**
  * Class for Nokogiri::XML::SAX::PushParser
@@ -159,7 +151,8 @@ public class XmlSaxPushParser extends RubyObject
 
     if (!options.recover && parserTask.getErrorCount() > errorCount0) {
       terminateTask(context.runtime);
-      throw ex = parserTask.getLastError();
+      ex = parserTask.getLastError().toThrowable();
+      throw ex;
     }
 
     return this;
@@ -278,16 +271,15 @@ public class XmlSaxPushParser extends RubyObject
     getErrorCount()
     {
       // check for null because thread may not have started yet
-      if (parser.getNokogiriHandler() == null) { return 0; }
-      return parser.getNokogiriHandler().getErrorCount();
+      if (parser.getNokogiriErrorHandler() == null) { return 0; }
+      return parser.getNokogiriErrorHandler().getErrors().size();
     }
 
-    synchronized final RaiseException
+    synchronized final RubyException
     getLastError()
     {
-      return parser.getNokogiriHandler().getLastError();
+      List<RubyException> errors = parser.getNokogiriErrorHandler().getErrors();
+      return errors.get(errors.size() - 1);
     }
-
   }
-
 }

data/ext/java/nokogiri/internals/NokogiriEntityResolver.java

@@ -85,7 +85,7 @@ public class NokogiriEntityResolver implements EntityResolver2
   private void
   addError(String errorMessage)
   {
-    if (handler != null) { handler.errors.add(new Exception(errorMessage)); }
+    if (handler != null) { handler.addError(new Exception(errorMessage)); }
   }
 
   /**

data/ext/java/nokogiri/internals/NokogiriErrorHandler.java

@@ -1,11 +1,15 @@
 package nokogiri.internals;
 
-import java.util.ArrayList;
-import java.util.List;
-
+import nokogiri.XmlSyntaxError;
 import org.apache.xerces.xni.parser.XMLErrorHandler;
+import org.jruby.Ruby;
+import org.jruby.RubyException;
+import org.jruby.exceptions.RaiseException;
 import org.xml.sax.ErrorHandler;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * Super class of error handlers.
  *
@@ -17,23 +21,40 @@ import org.xml.sax.ErrorHandler;
  */
 public abstract class NokogiriErrorHandler implements ErrorHandler, XMLErrorHandler
 {
-  protected final List<Exception> errors;
+  private final Ruby runtime;
+  protected final List<RubyException> errors;
   protected boolean noerror;
   protected boolean nowarning;
 
   public
-  NokogiriErrorHandler(boolean noerror, boolean nowarning)
+  NokogiriErrorHandler(Ruby runtime, boolean noerror, boolean nowarning)
   {
-    this.errors = new ArrayList<Exception>(4);
+    this.runtime = runtime;
+    this.errors = new ArrayList<RubyException>(4);
     this.noerror = noerror;
     this.nowarning = nowarning;
   }
 
-  List<Exception>
+  public List<RubyException>
   getErrors() { return errors; }
 
   public void
-  addError(Exception ex) { errors.add(ex); }
+  addError(Exception ex)
+  {
+    addError(XmlSyntaxError.createXMLSyntaxError(runtime, ex));
+  }
+
+  public void
+  addError(RubyException ex)
+  {
+    errors.add(ex);
+  }
+
+  public void
+  addError(RaiseException ex)
+  {
+    addError(ex.getException());
+  }
 
   protected boolean
   usesNekoHtml(String domain)

data/ext/java/nokogiri/internals/NokogiriHandler.java

@@ -38,25 +38,19 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler
   private final Ruby runtime;
   private final RubyClass attrClass;
   private final IRubyObject object;
-
-  /**
-   * Stores parse errors with the most-recent error last.
-   *
-   * TODO: should these be stored in the document 'errors' array?
-   * Currently only string messages are stored there.
-   */
-  private final LinkedList<RaiseException> errors = new LinkedList<RaiseException>();
+  private NokogiriErrorHandler errorHandler;
 
   private Locator locator;
   private boolean needEmptyAttrCheck;
 
   public
-  NokogiriHandler(Ruby runtime, IRubyObject object)
+  NokogiriHandler(Ruby runtime, IRubyObject object, NokogiriErrorHandler errorHandler)
   {
     assert object != null;
     this.runtime = runtime;
     this.attrClass = (RubyClass) runtime.getClassFromPath("Nokogiri::XML::SAX::Parser::Attribute");
     this.object = object;
+    this.errorHandler = errorHandler;
     charactersBuilder = new StringBuilder();
     String objectName = object.getMetaClass().getName();
     if ("Nokogiri::HTML4::SAX::Parser".equals(objectName)) { needEmptyAttrCheck = true; }
@@ -253,9 +247,9 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler
     try {
       final String msg = ex.getMessage();
       call("error", runtime.newString(msg == null ? "" : msg));
-      addError(XmlSyntaxError.createError(runtime, ex).toThrowable());
+      errorHandler.addError(ex);
     } catch (RaiseException e) {
-      addError(e);
+      errorHandler.addError(e);
       throw e;
     }
   }
@@ -282,22 +276,10 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler
     call("warning", runtime.newString(msg == null ? "" : msg));
   }
 
-  protected synchronized void
-  addError(RaiseException e)
-  {
-    errors.add(e);
-  }
-
   public synchronized int
   getErrorCount()
   {
-    return errors.size();
-  }
-
-  public synchronized RaiseException
-  getLastError()
-  {
-    return errors.getLast();
+    return errorHandler.getErrors().size();
   }
 
   private void

data/ext/java/nokogiri/internals/NokogiriNonStrictErrorHandler.java

@@ -1,6 +1,7 @@
 package nokogiri.internals;
 
 import org.apache.xerces.xni.parser.XMLParseException;
+import org.jruby.Ruby;
 import org.xml.sax.SAXException;
 import org.xml.sax.SAXParseException;
 
@@ -13,21 +14,21 @@ import org.xml.sax.SAXParseException;
 public class NokogiriNonStrictErrorHandler extends NokogiriErrorHandler
 {
   public
-  NokogiriNonStrictErrorHandler(boolean noerror, boolean nowarning)
+  NokogiriNonStrictErrorHandler(Ruby runtime, boolean noerror, boolean nowarning)
   {
-    super(noerror, nowarning);
+    super(runtime, noerror, nowarning);
   }
 
   public void
   warning(SAXParseException ex) throws SAXException
   {
-    errors.add(ex);
+    addError(ex);
   }
 
   public void
   error(SAXParseException ex) throws SAXException
   {
-    errors.add(ex);
+    addError(ex);
   }
 
   public void
@@ -38,7 +39,7 @@ public class NokogiriNonStrictErrorHandler extends NokogiriErrorHandler
     // found in the prolog, instead it will keep calling this method and we'll
     // keep inserting the error in the document errors array until we run
     // out of memory
-    errors.add(ex);
+    addError(ex);
     String message = ex.getMessage();
 
     // The problem with Xerces is that some errors will cause the
@@ -53,19 +54,19 @@ public class NokogiriNonStrictErrorHandler extends NokogiriErrorHandler
   public void
   error(String domain, String key, XMLParseException e)
   {
-    errors.add(e);
+    addError(e);
   }
 
   public void
   fatalError(String domain, String key, XMLParseException e)
   {
-    errors.add(e);
+    addError(e);
   }
 
   public void
   warning(String domain, String key, XMLParseException e)
   {
-    errors.add(e);
+    addError(e);
   }
 
   /*

data/ext/java/nokogiri/internals/NokogiriNonStrictErrorHandler4NekoHtml.java

@@ -1,6 +1,7 @@
 package nokogiri.internals;
 
 import org.apache.xerces.xni.parser.XMLParseException;
+import org.jruby.Ruby;
 import org.xml.sax.SAXException;
 import org.xml.sax.SAXParseException;
 
@@ -20,15 +21,15 @@ public class NokogiriNonStrictErrorHandler4NekoHtml extends NokogiriErrorHandler
 {
 
   public
-  NokogiriNonStrictErrorHandler4NekoHtml(boolean nowarning)
+  NokogiriNonStrictErrorHandler4NekoHtml(Ruby runtime, boolean nowarning)
   {
-    super(false, nowarning);
+    super(runtime, false, nowarning);
   }
 
   public
-  NokogiriNonStrictErrorHandler4NekoHtml(boolean noerror, boolean nowarning)
+  NokogiriNonStrictErrorHandler4NekoHtml(Ruby runtime, boolean noerror, boolean nowarning)
   {
-    super(noerror, nowarning);
+    super(runtime, noerror, nowarning);
   }
 
   public void
@@ -40,13 +41,13 @@ public class NokogiriNonStrictErrorHandler4NekoHtml extends NokogiriErrorHandler
   public void
   error(SAXParseException ex) throws SAXException
   {
-    errors.add(ex);
+    addError(ex);
   }
 
   public void
   fatalError(SAXParseException ex) throws SAXException
   {
-    errors.add(ex);
+    addError(ex);
   }
 
   /**
@@ -64,7 +65,7 @@ public class NokogiriNonStrictErrorHandler4NekoHtml extends NokogiriErrorHandler
   public void
   error(String domain, String key, XMLParseException e)
   {
-    errors.add(e);
+    addError(e);
   }
 
   /**
@@ -82,7 +83,7 @@ public class NokogiriNonStrictErrorHandler4NekoHtml extends NokogiriErrorHandler
   public void
   fatalError(String domain, String key, XMLParseException e)
   {
-    errors.add(e);
+    addError(e);
   }
 
   /**
@@ -100,7 +101,7 @@ public class NokogiriNonStrictErrorHandler4NekoHtml extends NokogiriErrorHandler
   public void
   warning(String domain, String key, XMLParseException e)
   {
-    errors.add(e);
+    addError(e);
   }
 
 }

data/ext/java/nokogiri/internals/NokogiriStrictErrorHandler.java

@@ -1,6 +1,7 @@
 package nokogiri.internals;
 
 import org.apache.xerces.xni.parser.XMLParseException;
+import org.jruby.Ruby;
 import org.xml.sax.SAXException;
 import org.xml.sax.SAXParseException;
 
@@ -14,23 +15,23 @@ import org.xml.sax.SAXParseException;
 public class NokogiriStrictErrorHandler extends NokogiriErrorHandler
 {
   public
-  NokogiriStrictErrorHandler(boolean noerror, boolean nowarning)
+  NokogiriStrictErrorHandler(Ruby runtime, boolean noerror, boolean nowarning)
   {
-    super(noerror, nowarning);
+    super(runtime, noerror, nowarning);
   }
 
   public void
   warning(SAXParseException spex) throws SAXException
   {
     if (!nowarning) { throw spex; }
-    else { errors.add(spex); }
+    else { addError(spex); }
   }
 
   public void
   error(SAXParseException spex) throws SAXException
   {
     if (!noerror) { throw spex; }
-    else { errors.add(spex); }
+    else { addError(spex); }
   }
 
   public void
@@ -43,7 +44,7 @@ public class NokogiriStrictErrorHandler extends NokogiriErrorHandler
   error(String domain, String key, XMLParseException e) throws XMLParseException
   {
     if (!noerror) { throw e; }
-    else { errors.add(e); }
+    else { addError(e); }
   }
 
   public void
@@ -56,6 +57,6 @@ public class NokogiriStrictErrorHandler extends NokogiriErrorHandler
   warning(String domain, String key, XMLParseException e) throws XMLParseException
   {
     if (!nowarning) { throw e; }
-    if (!usesNekoHtml(domain)) { errors.add(e); }
+    else { addError(e); }
   }
 }

data/ext/java/nokogiri/internals/SaveContextVisitor.java

@@ -673,6 +673,8 @@ public class SaveContextVisitor
       if (!isEmpty(name) && noEmpty) {
         buffer.append("</").append(name).append('>');
       }
+    } else if (asXhtml && !isEmpty(name)) {
+      buffer.append("</").append(name).append('>');
     }
     if (needBreakInClosing(element)) {
       if (!containsText(element)) { indentation.pop(); }

data/ext/java/nokogiri/internals/XmlDomParserContext.java

@@ -1,30 +1,24 @@
 package nokogiri.internals;
 
-import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
-import static nokogiri.internals.NokogiriHelpers.isBlank;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-
+import nokogiri.XmlDocument;
+import nokogiri.XmlDtd;
+import nokogiri.XmlSyntaxError;
 import org.apache.xerces.parsers.DOMParser;
-import org.jruby.Ruby;
-import org.jruby.RubyArray;
-import org.jruby.RubyClass;
-import org.jruby.RubyFixnum;
+import org.jruby.*;
 import org.jruby.exceptions.RaiseException;
-import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.Helpers;
+import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.w3c.dom.Document;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 import org.xml.sax.SAXException;
 
-import nokogiri.NokogiriService;
-import nokogiri.XmlDocument;
-import nokogiri.XmlDtd;
-import nokogiri.XmlSyntaxError;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import static nokogiri.internals.NokogiriHelpers.isBlank;
 
 /**
  * Parser class for XML DOM processing. This class actually parses XML document
@@ -48,7 +42,6 @@ public class XmlDomParserContext extends ParserContext
   protected static final String FEATURE_NOT_EXPAND_ENTITY =
     "http://apache.org/xml/features/dom/create-entity-ref-nodes";
   protected static final String FEATURE_VALIDATION = "http://xml.org/sax/features/validation";
-  private static final String XINCLUDE_FEATURE_ID = "http://apache.org/xml/features/xinclude";
   private static final String SECURITY_MANAGER = "http://apache.org/xml/properties/security-manager";
 
   protected ParserContext.Options options;
@@ -69,17 +62,17 @@ public class XmlDomParserContext extends ParserContext
     this.options = new ParserContext.Options(RubyFixnum.fix2long(options));
     java_encoding = NokogiriHelpers.getValidEncodingOrNull(encoding);
     ruby_encoding = encoding;
-    initErrorHandler();
+    initErrorHandler(runtime);
     initParser(runtime);
   }
 
   protected void
-  initErrorHandler()
+  initErrorHandler(Ruby runtime)
   {
     if (options.recover) {
-      errorHandler = new NokogiriNonStrictErrorHandler(options.noError, options.noWarning);
+      errorHandler = new NokogiriNonStrictErrorHandler(runtime, options.noError, options.noWarning);
     } else {
-      errorHandler = new NokogiriStrictErrorHandler(options.noError, options.noWarning);
+      errorHandler = new NokogiriStrictErrorHandler(runtime, options.noError, options.noWarning);
     }
   }
 
@@ -161,12 +154,10 @@ public class XmlDomParserContext extends ParserContext
   mapErrors(ThreadContext context, NokogiriErrorHandler errorHandler)
   {
     final Ruby runtime = context.runtime;
-    final List<Exception> errors = errorHandler.getErrors();
+    final List<RubyException> errors = errorHandler.getErrors();
     final IRubyObject[] errorsAry = new IRubyObject[errors.size()];
     for (int i = 0; i < errors.size(); i++) {
-      XmlSyntaxError xmlSyntaxError = XmlSyntaxError.createXMLSyntaxError(runtime);
-      xmlSyntaxError.setException(errors.get(i));
-      errorsAry[i] = xmlSyntaxError;
+      errorsAry[i] = errors.get(i);
     }
     return runtime.newArrayNoCopy(errorsAry);
   }