भाषा में भाषा या Scala में XPath एम्बेड करें

स्काला एक बेहतरीन भाषा है। आप उसके प्यार में पड़ सकते हैं। कोड संक्षिप्त हो सकता है, लेकिन समझने योग्य है; लचीला, लेकिन दृढ़ता से टाइप किया गया। पूरी तरह से सोचा जाने वाले उपकरण आपको भाषा से लड़ने के लिए नहीं, बल्कि उस पर अपने विचारों को व्यक्त करने की अनुमति देते हैं।

लेकिन ये वही उपकरण आपको बेहद जटिल कोड लिखने की अनुमति देते हैं।
स्केलाज़-शैली स्मार्ट बैलेंसिंग या आकार-रहित कंप्यूटिंग का उपयोग करना एक गारंटी है कि इकाइयां आपके कोड को समझेंगी।

इस लेख में, मैं बात करूंगा कि क्या करना है, सबसे अधिक संभावना है, इसके लायक नहीं है।
मैं आपको बताऊंगा कि कैसे scala में एक अलग भाषा एम्बेड करें।

यद्यपि XPath और मैं एम्बेड करेंगे, वर्णित विधि किसी भी भाषा के लिए उपयुक्त है जिसके लिए आप एक सिंटैक्स ट्री बना सकते हैं।

कारणों

स्काला में xml के साथ काम करने के लिए सभी उपकरणों का उपयोग करने की क्षमता है, जो जावा में है (और उनमें से कई हैं)। लेकिन कोड आपको पुराने पुराने जावा कोड की याद दिलाएगा। बहुत खुश संभावना नहीं।

भाषा सिंटैक्स में निर्मित एक देशी xml है:

scala> <root> | <node attr="aaa"/> | <node attr="111"> text</node> | </root> res0: scala.xml.Elem = <root> <node attr="aaa"/> <node attr="111"> text</node> </root> scala> res0 \\ "node" res1: scala.xml.NodeSeq = NodeSeq(<node attr="aaa"/>, <node attr="111"> text</node>) scala> res1 \\ "@attr" res2: scala.xml.NodeSeq = NodeSeq(aaa, 111) 

ऐसा लगता है कि यह खुशी है, लेकिन नहीं। यह केवल XPath जैसा दिखता है। यद्यपि थोड़े जटिल प्रश्न बोझिल और अपठनीय हो जाते हैं।

लेकिन स्काला के साथ कुछ परिचित होने के बाद, यह स्पष्ट हो जाता है कि निर्माता निराला को स्केलेबल भाषा नहीं कहते हैं। और अगर कुछ याद आ रहा है, तो यह जोड़ा जा सकता है।

मैंने खुद को भाषा में सुविधाजनक एकीकरण के साथ XPath के जितना संभव हो सके उतना ही कार्य निर्धारित किया।

परिणाम

यहाँ सभी घटनाक्रम: https://github.com/senia-psm/scala-xpath.git

क्या और कैसे

लक्ष्य प्राप्त करने का तरीका विशिष्ट रूप से लक्ष्य द्वारा ही निर्धारित किया जाता है।
XPath को डीएसएल के रूप में एम्बेड करना स्पष्ट रूप से विफल हो जाएगा। अन्यथा, यह अब XPath नहीं होगा। स्काला में एक XPath अभिव्यक्ति को केवल एक स्ट्रिंग के रूप में रखा जा सकता है।
जिसका अर्थ है:

1. पार्सर कॉम्बिनेटर । हमें सत्यापन के लिए स्ट्रिंग को पार्स करना होगा।
2. स्ट्रिंग इंटरपोलेशन । XPath में वैरिएबल और फ़ंक्शंस को एम्बेड करने के लिए।
3. मैक्रो । संकलन चरण में सत्यापन के लिए।

ऑब्जेक्ट मॉडल तैयार करें।

XPath 1.0 विनिर्देशन लें और इसे स्कैला पर फिर से लिखें।
लगभग सभी तर्क प्रकार प्रणाली और स्काला इनहेरिटेंस तंत्र के माध्यम से व्यक्त किए जाते हैं। अपवाद आवश्यकता के माध्यम से प्रतिबंध के स्थानों के एक जोड़े में हैं।
यहां यह "सील" कीवर्ड को ध्यान देने योग्य है, जो इस फ़ाइल के बाहर एक वर्ग (या एक इंटरफ़ेस को लागू करने) को विरासत में प्राप्त करने पर प्रतिबंध लगाता है। विशेष रूप से, नमूने की तुलना करते समय, "सील" कंपाइलर को यह सत्यापित करने की अनुमति देता है कि सभी संभावित विकल्पों को ध्यान में रखा गया है।

पारसीम एक्सपीथ

पार्सर्स (और डब्ल्यू 3 सी विनिर्देशों की साक्षरता) का संयोजन आपको बिना किसी हिचकिचाहट के एक पार्सर लिखने की अनुमति देता है।
वास्तव में, हम दूसरी बार विनिर्देश को फिर से लिख रहे हैं। एकमात्र महत्वपूर्ण अंतर यह है कि मैंने पुनरावर्ती परिभाषाओं को "चक्रीय" वाले (प्रतिनिधि और प्रतिनिधि) के साथ बदल दिया।

उदाहरण के लिए:

विशिष्टता:

  [१५] प्राइमरी एक्सप्रैस: = वैरिएबल रेफरेंस	
                                       |  '(' एक्प्राप्ट ')' '	
                                       |  शाब्दिक	
                                       |  संख्या	
                                       |  फंक्शन कॉल 

पार्सर :

  def primaryExpr: Parser[PrimaryExpr] = variableReference | `(` ~> expr <~ `)` ^^ { GroupedExpr } | functionCall | number | literal 

एकमात्र शर्त यह है कि आपको यह सुनिश्चित करने की आवश्यकता है कि सबसे "सख्त" पार्सर संघ के माध्यम से जाते हैं "|" बाकी से पहले। इस उदाहरण में, शाब्दिक स्पष्ट रूप से सफल होगा जहाँ भी फ़ंक्शनकॉल सफल होता है क्योंकि यह सफलतापूर्वक फ़ंक्शन के नाम को पार्स करता है, इसलिए यदि आप पहले शाब्दिक रूप से डालते हैं, तो यह कार्य करने के लिए बस नहीं मिलेगा।
पार्सर्स का पूरा सेट डेढ़ सौ लाइनों में फिट होता है, जो ऑब्जेक्ट मॉडल की परिभाषा से काफी कम है।

चरों को मिलाएं

अभिव्यक्ति में चर जोड़ने के लिए, हम स्ट्रिंग प्रक्षेप तंत्र का उपयोग करेंगे, जो संस्करण 2.10 में दिखाई दिया।
तंत्र काफी सरल है: एक पंक्ति का सामना करने से पहले (जिसके बिना कोई स्थान) वैध विधि नाम है, संकलक एक साधारण रूपांतरण करता है:

 t"strinf $x interpolation ${ obj.name.toString } " StringContext("strinf ", " interpolation ", " ").t(x, { obj.name.toString }) 

चर और भावों की घटनाओं से स्ट्रिंग को टुकड़ों में तोड़ दिया जाता है और StringContext फ़ैक्टरी विधि से पारित कर दिया जाता है। स्ट्रिंग से पहले का नाम विधि के नाम के रूप में उपयोग किया जाता है, और सभी चर और अभिव्यक्तियाँ इस विधि को मापदंडों के रूप में पारित की जाती हैं।
यदि यह "s" और "f" जैसी विधियों के साथ समाप्त होता है, तो ऐसे तरीकों के लिए जो StringContext में नहीं हैं, संकलक एक अंतर्निहित वर्ग की तलाश करता है - StringContext के ऊपर एक आवरण जिसमें वांछित विधि होती है। इस तरह की खोज स्कैला के लिए एक सामान्य तंत्र है और सीधे स्ट्रिंग प्रक्षेप पर लागू नहीं होती है।
अंतिम कोड:

  new MyStringContextHelper(StringContext("strinf ", " interpolation ", " ")).t(x, { obj.name.toString }) 

लेकिन हमारे पार्सर का क्या? अब हमारे पास पात्रों का एक निरंतर क्रम नहीं है। और पात्रों का क्रम है और कुछ और।
क्या सारा काम नाले से नीचे है?
यह वह जगह है जहाँ न केवल वर्णों के एक क्रम को पार्स करने की क्षमता का पता चलता है।
हमारे पास पात्रों का क्रम है और कुछ और (उस पर बाद में)। यह केवल या तो अवधारणा द्वारा वर्णित है। एक हाब्र पर कुछ लेखों के बारे में या तो सिग्रलामी का अनुवाद किया ।
पार्सर्स की पूरी शक्ति हासिल करने के लिए, आपको बस कुछ सहायक उपकरण लिखने होंगे। विशेष रूप से, चार, स्ट्रिंग और रेगेक्स से संबंधित पार्सर में रूपांतरण।
यहां आपके लिए आवश्यक सभी उपकरण हैं: EitherParsers । यह सार प्रकार आर पर ध्यान देने योग्य है। इसके बारे में कोई धारणा नहीं बनाई गई है, इसलिए टूलकिट चर का प्रतिनिधित्व करने के लिए पहले से अज्ञात विधि के लिए उपयुक्त है।

हम संकलन में हस्तक्षेप करते हैं

मेरी राय में मैक्रों पर प्रलेखन और उचित उदाहरण कुछ ही हैं। लेकिन इसका मतलब यह नहीं है कि मैं एक विस्तृत विवरण लिखने जा रहा हूं कि मैक्रों क्या हैं और वे क्या खाते हैं।
सबसे पहले, आपको पता होना चाहिए कि मैक्रो उस समय कहा जाता है जब कंपाइलर मैक्रो कीवर्ड का उपयोग करके कार्यान्वित विधि का सामना करता है और मैक्रो कार्यान्वयन को नए बनाए गए सिंटैक्स ट्री को वापस करना चाहिए।
आइए देखें कि सबसे सरल उदाहरण के लिए हमें किस तरह का पेड़ देना चाहिए:

 scala> import scala.reflect.runtime.universe._ import scala.reflect.runtime.universe._ scala> showRaw(reify( "str" -> 'symb )) res0: String = Expr(Apply(Select(Apply(Select(Ident(scala.Predef), newTermName("any2ArrowAssoc")), List(Literal(Constant("str")))), newTermName("$minus$greater")), List(Apply(Select(Ident(scala.Symbol), newTermName("apply")), List(Literal(Constant("symb"))))))) 

अपने आप को ऐसा बनाने के लिए थोड़ी सी भी इच्छा नहीं है।
आइए देखें कि स्कैला हमें टाइपिंग और बिना मैनुअल काम के संरक्षण के साथ क्या प्रदान करता है।
एक तरफ, बहुत कुछ नहीं: शाब्दिक विधि, जो आपको "बेसिक प्रकार" के कुछ सीमित सेट को सिंटैक्स पेड़ों में परिवर्तित करने की अनुमति देती है, और पुनरीक्षण करती है, जो आपके लिए सभी मैनुअल काम करता है, लेकिन केवल अगर आप इसे उसी पेड़ के रूप में बाहर से किसी भी चर को जोड़ते हैं फिर इस पेड़ की ब्याह विधि का उपयोग करें, विशेष रूप से डिज़ाइन किए गए प्रकार की अभिव्यक्ति के लिए अपनी इच्छा को सूचित करने के लिए Expt [T], जिसके परिणामस्वरूप प्रकार T के साथ एक नए पेड़ का हिस्सा है।
दूसरी ओर, ये विधियां काफी पर्याप्त हैं। उपलब्ध लोगों के आधार पर अतिरिक्त लिखा जा सकता है।

मैक्रो द्वारा संसाधित प्रक्षेप को जोड़ना अत्यंत ही संक्षिप्त है:

  implicit class XPathContext(sc: StringContext) { def xp(as: Any*): LocationPath = macro xpathImpl } 

मैक्रो-प्रोसेसिंग फ़ंक्शन निम्नानुसार घोषित किया गया है:

 def xpathImpl(c: Context)(as: c.Expr[Any]*): c.Expr[LocationPath] 

यह स्पष्ट है कि चर कहां से प्राप्त करें, लेकिन तार कैसे प्राप्त करें?
ऐसा करने के लिए, आप फ़ंक्शन के "लुक आउट" के संदर्भ का उपयोग कर सकते हैं। इसलिए बोलने के लिए, चारों ओर देखो।
अधिक सटीक रूप से, उस अभिव्यक्ति को देखें जिसके लिए लक्ष्य xp विधि कहा जाता है।
यह c.prefix का उपयोग करके किया जा सकता है।
लेकिन हम वहां क्या पाएंगे? यह पहले उल्लेख किया गया था कि स्ट्रींगकोनेक्स्ट ("स्ट्रिनफ", "इंटरपोलेशन", "") के रूप की अभिव्यक्ति होनी चाहिए।
आइए इसी पेड़ को देखें:

 scala> import scala.reflect.runtime.universe._ import scala.reflect.runtime.universe._ scala> showRaw(reify(StringContext("strinf ", " interpolation ", " "))) res0: String = Expr(Apply(Select(Ident(scala.StringContext), newTermName("apply")), List(Literal(Constant("strinf ")), Literal(Constant(" interpolation ")), Literal(Constant(" "))))) 

जैसा कि हम यहाँ से देख सकते हैं, आप सभी लाइनों को स्पष्ट रूप में प्राप्त कर सकते हैं, जो हम करेंगे:

  val strings = c.prefix.tree match { case Apply(_, List(Apply(_, ss))) => ss case _ => c.abort(c.enclosingPosition, "not a interpolation of XPath. Cannot extract parts.") } val chars = strings.map{ case c.universe.Literal(Constant(source: String)) => source.map{ Left(_) } case _ => c.abort(c.enclosingPosition, "not a interpolation of XPath. Cannot extract string.") } 

लेकिन न केवल प्रवेश द्वार बदल गया है। पार्सर का परिणाम अब हमारे ऑब्जेक्ट मॉडल से एक वस्तु नहीं हो सकता है - यह बस एक मूल्य के आधार पर नहीं बनाया जा सकता है, लेकिन प्रपत्र c.Expr [कोई भी] के एक पैरामीटर पर।

हमारे पार्सर को उसी के अनुसार बदलें। यदि, परिणामस्वरूप, एक बाहरी चर कम से कम किसी भी तरह दिखाई दे सकता है, तो पार्सर अब टी वापस नहीं कर सकता है, लेकिन सी। एक्सप्रिट [टी] वापस करना होगा। संबंधित प्रारंभिक से गैर-प्राथमिक प्रकार के रूपांतरणों के लिए, हम उदाहरण के लिए, उपलब्ध लोगों के आधार पर सहायक शाब्दिक तरीके लिखते हैं:

  def literal(name: QName): lc.Expr[QName] = reify{ QName(literal(name.prefix).splice, literal(name.localPart).splice) } 

इस तरह के सभी कार्यों का सिद्धांत बहुत सरल है: हम तर्क को काफी प्राथमिक भागों में पार्स करते हैं और इसे पुन: प्रस्तुत करने के लिए आश्वस्त करते हैं।

इसके लिए कुछ यांत्रिक कार्यों की आवश्यकता होगी, लेकिन हमारे पार्सर में बहुत बदलाव नहीं होगा।

अंतिम चरण कई पार्सर्स का परिचय है जो इनपुट पर एक चर को पार्स कर सकते हैं।
यहाँ चर एम्बेड करने के लिए पार्सर है :

  accept("xc.Expr[Any]", { case Right(e) => e } ) ^? ({ case e: xc.Expr[BigInt] if confirmType(e, tagOfBigInt.tpe) => reify{ CustomIntVariableExpr(VariableReference(QName(None, NCName(xc.literal(nextVarName).splice))), e.splice) } case e: xc.Expr[Double] if confirmType(e, xc.universe.definitions.DoubleClass.toType) => reify{ CustomDoubleVariableExpr(VariableReference(QName(None, NCName(xc.literal(nextVarName).splice))), e.splice) } case e: xc.Expr[String] if confirmType(e, xc.universe.definitions.StringClass.toType) => reify{ CustomStringVariableExpr(VariableReference(QName(None, NCName(xc.literal(nextVarName).splice))), e.splice) } }, e => s"Int, Long, BigInt, Double or String expression expected, $e found." ) 

प्रारंभिक पार्सर "स्वीकार करें (" xc.Expr [कोई भी] ", {केस राइट (e) => e})" बहुत सरल है - यह किसी भी राइट कंटेनर को एक पेड़ के साथ स्वीकार करता है और इस पेड़ को वापस करता है।
आगे रूपांतरण यह निर्धारित करता है कि क्या इस चर का उपयोग तीन वांछित प्रकारों में से एक के रूप में किया जा सकता है और फिर, इस तरह के उपयोग के लिए परिवर्तित होता है।

परिणामस्वरूप, हमें निम्न व्यवहार मिलता है:

 scala> val xml = <book attr="111"/> xml: scala.xml.Elem = <book attr="111"/> scala> val os = Option("111") os: Option[String] = Some(111) scala> xml \\ xp"*[@attr = $os]" // Option[String]    <console>:16: error: Int, Long, BigInt, Double or String expression expected, Expr[Nothing](os) found. xml \\ xp"*[@attr = $os]" ^ scala> xml \\ xp"*[@attr = ${ os.getOrElse("") } ]" //   String   res1: scala.xml.NodeSeq = NodeSeq(<book attr="111"/>) 

और अगर त्रुटि संदेशों को अभी भी सुधारने की आवश्यकता है, तो चर पहले से ही काफी सुविधाजनक रूप से बनाए गए हैं।

एम्बेडिंग फ़ंक्शन को बहुत अधिक कोड की आवश्यकता होती है (23 विकल्प, 0 से 22 मापदंडों के विकल्पों में से एक) और यह बहुत सुविधाजनक काम नहीं करता है, क्योंकि आपको केवल किसी को भी स्वीकार करने की आवश्यकता है, लेकिन मूल रूप से एक नोडलिस्ट (लेकिन शायद एक पंक्ति या डबल या तो) आता है:

 scala> import org.w3c.dom.NodeList import org.w3c.dom.NodeList scala> val isAllowedAttributeOrText = (_: Any, _: Any) match { // - ,       | case (a: NodeList, t: NodeList) if a.getLength == 1 && t.getLength == 1 => | a.head.getTextContent == "aaa" || | t.head.getTextContent.length > 4 | case _ => false | } isAllowedAttributeOrText: (Any, Any) => Boolean = <function2> scala> val xml = <root attr="11111" ><inner attr="111" /><inner attr="aaa" >inner text</inner> text </root> xml: scala.xml.Elem = <root attr="11111"><inner attr="111"/><inner attr="aaa">inner text</inner> text </root> scala> xml \\ xp"*[$isAllowedAttributeOrText(@attr, text())]" res0: scala.xml.NodeSeq = NodeSeq(<root attr="11111"><inner attr="111"/><inner attr="aaa">inner text</inner> text </root>, <inner attr="aaa">inner text</inner>) 

यहां हमें XPath सिंटैक्स से पहला मूर्खता मिला (वेरिएबल्स के बजाय फॉर्म $ {मनमाना कोड} की अभिव्यक्ति लिखने की संभावना को छोड़कर) - कार्यान्वित फ़ंक्शन को एक डॉलर से पहले होना चाहिए।

विधि कार्यान्वयन

स्वाभाविक रूप से, scala.xml.NodeSeq तरीके "\" और "\\" खुद जादू से प्रकट नहीं होते थे, उन्हें मॉडल के पैकेज ऑब्जेक्ट में निहित वर्ग का उपयोग करके जोड़ा जाता है।

इसी तरह के तरीके org.w3c.dom.Node और NodeList में बनाए गए हैं।

और परिणामस्वरूप XPath के आवेदन के साथ, कुछ समस्याएं उत्पन्न होती हैं।

अनारक्षित मुद्दे

Java.lang.System.setSecurityManager (नल) से छुटकारा पाएं । Com.sun.org.apache.xpath.internal.jaxp.XPathFactoryImpl के कार्यान्वयन को देखते हुए, कस्टम फ़ंक्शन हैंडलर जोड़ने का कोई अन्य तरीका नहीं है।

संकलन चरण में त्रुटियों को शोधन की आवश्यकता होती है।
यदि, गलत तरीके से निर्दिष्ट फ़ंक्शन के साथ, त्रुटि संदेश एकदम सही है (संकलक के तर्क के लिए एक अलग प्रशंसा):

 scala> xml \\ xp"*[$isAllowedAttributeOrText(@attr)]" <console>:1: error: type mismatch; found : (Any, Any) => Boolean required: Any => Any xml \\ xp"*[$isAllowedAttributeOrText(@attr)]" ^ 

तब अन्य सभी त्रुटियों के लिए, मानक संदेश प्रारूप का सम्मान नहीं किया जाता है और स्थिति लाइन की शुरुआत को इंगित करती है।
पिछले एक के विपरीत, इस समस्या को पूरी तरह से हल किया जा सकता है।

प्रदर्शन जब scala.xml के साथ काम करना चाहता है। वास्तव में, sc3.xml से w3c.dom में रूपांतरण पहले स्ट्रिंग और फिर रिवर्स के माध्यम से होता है।
एकमात्र संभव समाधान XPath को स्वयं को संभालना है।
साथ ही, इससे कार्यों के सुविधाजनक टाइपिंग से भी छुटकारा मिलेगा।

W3c.dom के साथ प्रदर्शन में थोड़ा सुधार किया जा सकता है। XPath को वर्तमान में एक स्ट्रिंग से संकलित किया गया है, हालांकि एक तैयार-निर्मित ऑब्जेक्ट मॉडल है। ऑब्जेक्ट मॉडल के बीच बदलने से XPath निर्माण में कुछ हद तक तेजी आ सकती है।

निष्कर्ष

XPath को गंभीर समस्याओं और सीमाओं के बिना स्काला में एकीकृत किया जा सकता है।
जहाँ भी विनिर्देशन उन्हें अनुमति देता है, मौजूदा दायरे से चर और कार्य मान्य होते हैं।
जब w3c.dom के साथ और कुछ सुधारों के साथ उपयोग किया जाता है, तो संकलन के दौरान अभिव्यक्ति को पार्स करने के कारण भी मामूली त्वरण संभव है।

सब कुछ बहुत सरल है। यह पहली नज़र में लगता है।
शुरुआत में, संकलन में एम्बेड करने का बहुत विचार नर्क उठाता है। परिणाम न्यूनतम प्रयास के साथ प्राप्त किया जाता है।
हां, कंपाइलर एपीआई को मुख्य पुस्तकालय की तुलना में बहुत खराब दस्तावेज किया जाता है, लेकिन यह तार्किक और समझ में आता है।
हां, IDEA पथ-निर्भर प्रकारों को अच्छी तरह से नहीं समझता है, लेकिन यह संकलक एपीआई सहित बहुत सुविधाजनक नेविगेशन प्रदान करता है, और अंतर्निहित रूपांतरणों को ध्यान में रखता है।