রুবি টেমপ্লেটিং освоয়ন: দক্ষ টেমপ্লেট প্রসেসিং-এর জন্য পার্সার বিল্ড করা

আজ, আমরা রুবি টেমপ্লেটিং-এ আমাদের যাত্রা চালিয়ে যাচ্ছি। লেক্সার inplace থাকায়, চলুন পরবর্তী ধাপে যাই: পার্সার।

গতবারেরা, আমরা স্ট্রিং ইন্টারপোলেশন দেখেছিলাম এবং তারপর, আমাদের নিজস্ব টেমপ্লেটিং ল্যাঙ্গুয়েজ তৈরি করার中略ে ডুব দিয়েছিলাম। আমরা শুরু করেছিলাম একটি লেক্সার ইমপ্লিমেন্ট করে যা একটি টেমপ্লেট পড়ে এবং সেটিকে টোকেনের একটি স্ট্রিমে কনভার্ট করে। আজ, আমরা সাথে পার্সার ইমপ্লিমেন্ট করব। আমরা ভাষা তত্ত্বের দিকে একটু ডুব দিব।

চলুন শুরু করি!

অ্যাবস্ট্র্যাক্ট সিনট্যাক্স ট্রি

আমাদের সিম্পল উদাহরণ টেমপ্লেট Welcome to {{name}}-এ ফিরে যাই। লেক্সার ব্যবহার করে স্ট্রিং টোকেনাইজ করার পর, আমরা একটি টোকেন লিস্ট পাই এরকম:

Magicbars::Lexer.tokenize("Welcome to {{name}}") # => [[:CONTENT, "Welcome to "], [:OPEN_EXPRESSION], [:IDENTIFIER, "name"], [:CLOSE]]

একটি গ্রামার ডিফাইন করা

গ্রামার ডিফাইন করতে, চলুন একটি ল্যাঙ্গুয়েজের থিওরেটিক্যাল বেসিস থেকে শুরু করি। অন্যান্য প্রোগ্রামিং ল্যাঙ্গুয়েজের মত, আমাদের টেমপ্লেটিং ল্যাঙ্গুয়েজ একটি কনটেক্সট-ফ্রি ল্যাঙ্গুয়েজ এবং তাই একটি কনটেক্সট-ফ্রি গ্রামার দিয়ে বর্ণনা করা যায়। (Wikipedia-এ গণিতের নোটেশন देखकर ভয় পাবেন না। কনসেপ্টটি প্রিটি স্ট্রেট ফরওয়ার্ড, এবং একটি ল্যাঙ্গুয়েজের গ্রামার নোটেট করার ডেভেলপার-ফ্রেন্ডলি পদ্ধতিও আছে।) একটি কনটেক্সট-ফ্রি গ্রামার হলো নিয়মের একটি সেট যা বর্ণনা করে একটি ল্যাঙ্গুয়েজের সব সম্ভাব্য স্ট্রিং কীভাবে কনস্ট্রাক্ট হয়। আমাদের টেমপ্লেটিং ল্যাঙ্গুয়েজের গ্রামার EBNF নোটেশনে দেখি:

template = statements; statements = { statement }; statement = CONTENT | expression | block_expression; expression = OPEN_EXPRESSION, IDENTIFIER, arguments, CLOSE; block_expression = OPEN_BLOCK, IDENTIFIER, arguments, CLOSE, statements, [ OPEN_INVERSE, CLOSE, statements ], OPEN_END_BLOCK, IDENTIFIER, CLOSE; arguments = { IDENTIFIER }; 

পার্সার বিল্ড করা

ভাষা তত্ত্ব এক পাশে রেখে, আসুন আসলে পার্সার বিল্ড করার মধ্যে ঢুকি। একটি আরও মিনিম্যাল, কিন্তু এখনও বৈধ, টেমপ্লেট দিয়ে শুরু করি: Welcome to Ruby Magic। এই টেমপ্লেটে কোনো এক্সপ্রেশন নেই এবং টোকেন লিস্ট শুধু একটি এলিমেন্ট ধারণ করে। এখানে সেটি কেমন দেখে:

[[:CONTENT, "Welcome to Ruby Magic"]]

module Magicbars class Parser def self.parse(tokens) new(tokens).parse end attr_reader :tokens def initialize(tokens) @tokens = tokens end def parse # Parsing starts here end end end

module Magicbars module Nodes class Template attr_reader :statements def initialize(statements) @statements = statements end end end end

module Magicbars module Nodes class Content attr_reader :content def initialize(content) @content = content end end end end

def parse Magicbars::Nodes::Template.new(parse_content) end def parse_content return unless tokens[0][0] == :CONTENT Magicbars::Nodes::Content.new(tokens[0][1]) end

Magicbars::Parser.parse(tokens) # => #>

Magicbars::Lexer.tokenize("Welcome to {{name}}") # => [[:CONTENT, "Welcome to "], [:OPEN_EXPRESSION], [:IDENTIFIER, "name"], [:CLOSE]]

module Magicbars module Nodes class Expression attr_reader :identifier, :arguments def initialize(identifier, arguments) @identifier = identifier @arguments = arguments end end end end module Magicbars module Nodes class Identifier attr_reader :value def initialize(value) @value = value.to_sym end end end end

def parse Magicbars::Nodes::Template.new(parse_statements) end def parse_statements results = [] while result = parse_statement results << result end results end

def parse_statement parse_content || parse_expression end

attr_reader :tokens, :position def initialize(tokens) @tokens = tokens @position = 0 end # ... def parse_content return unless token = tokens[position] return unless token[0] == :CONTENT @position += 1 Magicbars::Nodes::Content.new(token[1]) end

def parse_expression return unless token = tokens[position] return unless token[0] == :OPEN_EXPRESSION @position += 1 identifier = parse_identifier arguments = parse_arguments if !tokens[position] || tokens[position][0] != :CLOSE raise "Unexpected token #{tokens[position][0]}. Expected :CLOSE." end @position += 1 Magicbars::Nodes::Expression.new(identifier, arguments) end

def expect(*expected_tokens) upcoming = tokens[position, expected_tokens.size] if upcoming.map(&:first) == expected_tokens advance(expected_tokens.size) upcoming end end def advance(offset = 1) @position += offset end

def need(*required_tokens) upcoming = tokens[position, required_tokens.size] expect(*required_tokens) or raise "Unexpected tokens. Expected #{required_tokens.inspect} but got #{upcoming.inspect}" end

def parse_content if content = expect(:CONTENT) Magicbars::Nodes::Content.new(content[0][1]) end end def parse_expression return unless expect(:OPEN_EXPRESSION) identifier = parse_identifier arguments = parse_arguments need(:CLOSE) Magicbars::Nodes::Expression.new(identifier, arguments) end

def parse_identifier if identifier = expect(:IDENTIFIER) Magicbars::Nodes::Identifier.new(identifier[0][1]) end end

def repeat(method) results = [] while result = send(method) results << result end results end

def parse_statements repeat(:parse_statement) end def parse_arguments repeat(:parse_identifier) end

Magicbars::Parser.parse(tokens) # => # , # # > 

ব্লক এক্সপ্রেশন পার্স করা

আমাদের পার্সার ইমপ্লিমেন্টেশন কমপ্লিট করতে, আমাদের এখনও ব্লক এক্সপ্রেশন পার্স করা বাকি। রিমাইন্ডার হিসেবে, এখানে আমরা যে টেমপ্লেট পার্স করতে চাই সেটি:

Welcome to {{name}}! {{#if subscribed}} Thank you for subscribing to our mailing list. {{else}} Please sign up for our mailing list to be notified about new articles! {{/if}} Your friends at {{company_name}}

module Magicbars module Nodes class BlockExpression attr_reader :identifier, :arguments, :statements, :inverse_statements def initialize(identifier, arguments, statements, inverse_statements) @identifier = identifier @arguments = arguments @statements = statements @inverse_statements = inverse_statements end end end end

def parse_statement parse_content || parse_expression || parse_block_expression end

def parse_block_expression return unless expect(:OPEN_BLOCK) identifier = parse_identifier arguments = parse_arguments need(:CLOSE) statements = parse_statements if expect(:OPEN_INVERSE, :CLOSE) inverse_statements = parse_statements end need(:OPEN_END_BLOCK) if identifier.value != parse_identifier.value raise("Error. Identifier in closing expression does not match identifier in opening expression") end need(:CLOSE) Magicbars::Nodes::BlockExpression.new(identifier, arguments, statements, inverse_statements) end

যাত্রা চালিয়ে যাচ্ছে…

আমাদের নিজস্ব টেমপ্লেটিং ল্যাঙ্গুয়েজ ইমপ্লিমেন্ট করার দিকে যাত্রায় আমরা ভালো প্রগতি করেছি। ভাষা তত্ত্বে একটি ছোট ডিপের পর, আমরা আমাদের টেমপ্লেটিং ল্যাঙ্গুয়েজের জন্য একটি গ্রামার ডিফাইন করেছি এবং সেটি ব্যবহার করে স্ক্র্যাচ থেকে একটি পার্সার ইমপ্লিমেন্ট করেছি। লেক্সার এবং পার্সার দুটোই inplace থাকায়, আমাদের শুধু একটি ইন্টারপ্রেটার বাকি আছে ইন্টারপোলেটেড স্ট্রিং জেনারেট করার জন্য আমাদের টেমপ্লেট থেকে। আমরা এই পার্টটি RubyMagic-এর একটি আগামী एডিশনে কভার করব। Ruby Magic মেইলিংলিস্ট সাবস্ক্রাইব করুন, সেটি আউট হলে অ্যালার্ট পেতে।