Elixir 1.7

EEx.Engine व्यवहार




elixir

EEx.Engine व्यवहार

बेसिक EEx इंजन जो अमृत के साथ जहाज करता है।

एक इंजन को छह कार्यों को लागू करने की आवश्यकता है:

  • init(opts) - हर पाठ की शुरुआत में कहा जाता है और इसे प्रारंभिक अवस्था में लौटना चाहिए।

  • handle_body(state) - दस्तावेज़ की स्थिति प्राप्त करता है और इसे एक उद्धृत अभिव्यक्ति वापस करना होगा।

  • handle_text(state, text) - यह handle_text(state, text) प्राप्त करता है और एक नई उद्धृत अभिव्यक्ति को वापस करना चाहिए।

  • handle_expr(state, marker, expr) - यह handle_expr(state, marker, expr) प्राप्त करता है और एक नया राज्य वापस करना होगा।

  • handle_begin(state) - हर बार कहा जाता है कि खाली बफर के साथ एक नए राज्य की आवश्यकता है। आमतौर पर डू / एंड ब्लॉक, केस एक्सप्रेशन, अनाम फ़ंक्शन आदि के लिए कहा जाता है

  • handle_end(state) - handle_end(state) विपरीत और इसे उद्धृत अभिव्यक्ति वापस करना होगा

    मार्कर <% बाद वास्तव में क्या है। उदाहरण के लिए, <% foo %> में एक खाली मार्कर है, लेकिन <%= foo %> में मार्कर के रूप में "=" है। अब तक स्वीकृत मार्कर निम्न हैं:

    • ""
    • "="
    • "/"
    • "|"

    मार्कर "/" और "|" केवल कस्टम EEx इंजन में उपयोग के लिए हैं और डिफ़ॉल्ट रूप से कार्यान्वित नहीं किए जाते हैं। कार्यान्वयन के बिना उनका उपयोग करना EEx.SyntaxError

    यदि आपका इंजन सभी मार्करों को लागू नहीं करता है, तो कृपया सुनिश्चित करें कि उचित त्रुटि संदेश को उठाने के लिए EEx.Engine.handle_expr/3 पर वापस आता है।

    इस इंजन द्वारा डिफ़ॉल्ट रूप से कार्यान्वित किए गए मार्करों के बारे में अधिक जानकारी के लिए नीचे handle_expr/3 पढ़ें।

EEx.Engine सीधे इस्तेमाल किया जा सकता है अगर कोई उपरोक्त कार्यों के लिए डिफ़ॉल्ट कार्यान्वयन का उपयोग करना चाहता है।

सारांश

प्रकार

state()

कार्य

handle_assign(arg)

हैंडल भावों में असाइन किया गया है

handle_begin(previous)

नए बफर के रूप में एक खाली स्ट्रिंग लौटाता है

handle_body(quoted)

डिफ़ॉल्ट कार्यान्वयन केवल दी गई अभिव्यक्ति को वापस करता है

handle_end(quoted)

नए बफर का अंत

handle_expr/3

मार्करों के अनुसार अभिव्यक्ति के गुण

handle_text (बफर, पाठ)

डिफ़ॉल्ट कार्यान्वयन बस बफर को पाठ को संक्षिप्त करता है

init(opts)

प्रारंभिक बफर के रूप में एक खाली स्ट्रिंग लौटाता है

कॉलबैक

handle_begin(state)
handle_body(state)
handle_end(state)
handle_expr (राज्य, मार्कर, एक्सप)
handle_text (राज्य, पाठ)
init(opts)

प्रकार

राज्य ()

state() :: term()

कार्य

handle_assign (आर्ग)

handle_assign(Macro.t()) :: Macro.t()

हैंडल भावों में असाइन किया गया है।

लापता असाइनमेंट पर एक चेतावनी मुद्रित की जाएगी। भविष्य के संस्करण उठाएंगे।

इसे handle_assign(arg) साथ Macro.prewalk/2 handle_assign(arg) किसी भी कस्टम इंजन में जोड़ा जा सकता है:

def handle_expr(buffer, token, expr) do
  expr = Macro.prewalk(expr, &EEx.Engine.handle_assign/1)
  EEx.Engine.handle_expr(buffer, token, expr)
end

handle_begin (पिछले)

नए बफर के रूप में एक खाली स्ट्रिंग लौटाता है।

handle_body (उद्धृत)

डिफ़ॉल्ट कार्यान्वयन केवल दी गई अभिव्यक्ति को वापस करता है।

handle_end (उद्धृत)

नए बफर का अंत।

handle_expr (बफर, मार्कर, एक्सप)

मार्करों के अनुसार अभिव्यक्ति के गुण।

<% Elixir expression - inline with output %>
<%= Elixir expression - replace with result %>
<%/ Elixir expression - raise EEx.SyntaxError, to be implemented by custom engines %>
<%| Elixir expression - raise EEx.SyntaxError, to be implemented by custom engines %>

अन्य सभी मार्कर इस इंजन द्वारा कार्यान्वित नहीं किए जाते हैं।

handle_text (बफर, पाठ)

डिफ़ॉल्ट कार्यान्वयन बस बफर को पाठ को संक्षिप्त करता है।

init (opts)

प्रारंभिक बफर के रूप में एक खाली स्ट्रिंग लौटाता है।

कॉलबैक

handle_begin (राज्य)

handle_begin(state()) :: state()

handle_body (राज्य)

handle_body(state()) :: Macro.t()

handle_end (राज्य)

handle_end(state()) :: Macro.t()

handle_expr (राज्य, मार्कर, एक्सप)

handle_expr(state(), marker :: String.t(), expr :: Macro.t()) :: state()

handle_text (राज्य, पाठ)

handle_text(state(), text :: String.t()) :: state()

init (opts)

init(opts :: keyword()) :: state()