rley 0.1.09 → 0.1.10

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ODQ1OTNmNjQ5YjA1NTFkMWU2MjczMDgzYjI1OGMwYjU4MGMzOWU4Mw==
+    YzgzNjZlYTc1NjRjYTkxZTNkNmVkNmE3MmY2OGRjNzAwYjBjM2E0MQ==
   data.tar.gz: !binary |-
-    NDRhZTcyNDkxZjYxZWIwYzA4YWVlM2Q5NTNkZDAwNGM1MTI2YjdlMQ==
+    MmMzNWNiZjRlZDcyOTJiZmE0Nzc4Y2ZjYjBhYmYyM2ZkNTE5MzM5OQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZThlM2MwMGYzYmNlZmU4MzVjM2I3YWQwNTAwYzA3MWU1NzhjMGI1MTZmYTI4
-    NDU5ZTg4NzVjZTBlOGViYmQxNDJhYjQyM2M3NjM3ZTZhNDFiMzU1NjZmYTdj
-    YjM5YjRkYWFhZGNjNmYwOTVmN2QwODM2N2IyNGExMzgzODFiNjM=
+    YTRiZTJhZjRkOTcyYzQ3NTE4ZDFmZGQ1NTI4ZGM3MTdhOGVlN2Q2NGFlNWE1
+    NmVlMmE2NGUzYjJhOTE0MTJjNmY0ZmI3MDMzYTA3N2VjYzVlNGQ4ODNhNDc2
+    MzdiYzdkMzhlZWVmYTJhNWUxMjg4ZWM2OTQ3Zjg3ZDcyNDY1MjE=
   data.tar.gz: !binary |-
-    MDIwNDE2Y2RiODNlN2UwZGRhNzY0NTJjMjVjZjE1ZmU5NmNjNDhiMDBkOGRi
-    Yjk3OWViNDdlOGNkMWY3NTE1MDIxNTEzZWI3N2M5OTVhYzFkNDg2OWU4ODVm
-    NzE4Mjg5MzliNThhOTk5ZDRiM2RiNDhmNmZhYzdjYzRlYzFiMmI=
+    YmE3MmE2OGM5MzBhMDY4NDgyNTA5MmY0NjA3ZjcyNDQ3Yzg3NDJiNTJjNzc0
+    NjczZDFjN2QyNTIwODNmYmE5ZGQwMzBjMTYwMWQwNDJkN2UwYWQ5MTc4MWJh
+    OWU5OTdlNmFkNWYyNTA2NzU3NWI0MjUxZTM1NjRmMzE4MGNhOGE=

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 0.1.10 / 2014-12-14
+* [CHANGE] Added more examples in `examples` folder (e.g. parsing then parse tree ).
+* [CHANGE] File `rley.rb`: added more requires of the library to ease integration.
+
 ### 0.1.09 / 2014-12-14
 * [CHANGE] Source code refactored to please Rubocop (0.28.0)
 * [CHANGE] File `.rubucop.yml`  Disabled VariableNam style cop.

data/examples/parsers/parsing_abc.rb

@@ -0,0 +1,72 @@
+# Purpose: to demonstrate how to build and render a parse tree
+
+require 'rley'  # Load the gem
+
+# Steps to render a parse tree (of a valid parsed input):
+# 1. Define a grammar
+# 2. Create a tokenizer for the language
+# 3. Create a parser for that grammar
+# 4. Tokenize the input
+# 5. Let the parser process the input
+# 6. Generate a parse tree from the parse result
+# 7. Render the parse tree (in JSON)
+
+########################################
+# Step 1. Define a grammar for a very simple language
+# It recognizes/generates strings like 'b', 'abc', 'aabcc', 'aaabccc',...
+# (based on example in N. Wirth's book "Compiler Construction", p. 6)
+# Let's create the grammar step-by-step with the grammar builder:
+builder = Rley::Syntax::GrammarBuilder.new
+builder.add_terminals('a', 'b', 'c')
+builder.add_production('S' => 'A')
+builder.add_production('A' => %w(a A c))
+builder.add_production('A' => 'b')
+
+# And now build the grammar...
+grammar_abc = builder.grammar
+
+
+########################################
+# 2. Create a tokenizer for the language
+# The tokenizer transforms the input into an array of tokens
+def tokenizer(aText, aGrammar)
+  tokens = aText.chars.map do |ch|
+    terminal = aGrammar.name2symbol[ch]
+    fail StandardError, "Unknown input character '#{ch}'" if terminal.nil?
+    Rley::Parser::Token.new(ch, terminal)
+  end
+  
+  return tokens
+end
+
+########################################
+# Step 3. Create a parser for that grammar
+parser = Rley::Parser::EarleyParser.new(grammar_abc)
+
+########################################
+# Step 3. Tokenize the input
+valid_input = 'aabcc'
+tokens = tokenizer(valid_input, grammar_abc)
+
+########################################
+# Step 5. Let the parser process the input
+result = parser.parse(tokens)
+
+
+########################################
+# Step 6. Generate a parse tree from the parse result
+ptree = result.parse_tree
+
+########################################
+# Step 7. Render the parse tree (in JSON)
+# Let's create a parse tree visitor
+visitor = Rley::ParseTreeVisitor.new(ptree)
+
+#Here we create a renderer object...
+renderer = Rley::Formatter::Json.new(STDOUT)
+
+# Now emit the parse tree as JSON on the console output
+puts "JSON rendering of the parse tree for '#{valid_input}' input:"
+renderer.render(visitor)
+
+# End of file

data/examples/recognizers/recognizer_abc.rb

@@ -0,0 +1,71 @@
+# Purpose: to demonstrate how to build a recognizer
+# A recognizer is a kind of parser that indicates whether the input
+# complies to the grammar or not.
+
+require 'rley'  # Load the gem
+
+# Steps to build a recognizer:
+# 1. Define a grammar
+# 2. Create a parser for that grammar
+# 3. Build the input
+# 4. Let the parser process the input
+# 5. Check the parser's result to see whether the input was valid (=recognized)
+
+########################################
+# Step 1. Define a grammar for a very simple language
+# It recognizes/generates strings like 'b', 'abc', 'aabcc', 'aaabccc',...
+# (based on example in N. Wirth's book "Compiler Construction", p. 6)
+# Let's create the grammar step-by-step with the grammar builder:
+builder = Rley::Syntax::GrammarBuilder.new
+builder.add_terminals('a', 'b', 'c')
+builder.add_production('S' => 'A')
+builder.add_production('A' => %w(a A c))
+builder.add_production('A' => 'b')
+
+# And now build the grammar...
+grammar_abc = builder.grammar
+
+# Keep track of the terminal symbols of the grammar:
+term_a = grammar_abc.name2symbol['a']
+term_b = grammar_abc.name2symbol['b']
+term_c = grammar_abc.name2symbol['c']
+
+########################################
+# Step 2. Create a parser for that grammar
+parser = Rley::Parser::EarleyParser.new(grammar_abc)
+
+########################################
+# Step 3. Build the input
+# Mimicking the output of a tokenizer
+valid_input = [
+  Rley::Parser::Token.new('a', term_a),
+  Rley::Parser::Token.new('a', term_a),
+  Rley::Parser::Token.new('b', term_b),
+  Rley::Parser::Token.new('c', term_c),
+  Rley::Parser::Token.new('c', term_c)
+]
+
+########################################
+# Step 4. Let the parser process the input
+result = parser.parse(valid_input)
+
+
+########################################
+# Step 5. Check the parser's result to see whether the input was valid
+puts "Successful parse of 'aabcc'? #{result.success?}"
+# Output: Successful parse of 'aabcc'? true
+
+
+
+# Let's redo steps 3, 4, 5 again with an invalid input.
+invalid_input = [
+  Rley::Parser::Token.new('a', term_a),
+  Rley::Parser::Token.new('a', term_a),
+  Rley::Parser::Token.new('b', term_b),
+  Rley::Parser::Token.new('c', term_c)
+]
+result = parser.parse(invalid_input)
+puts "Successful parse of 'aabc'? #{result.success?}"
+# Output: Successful parse of 'aabc'? false
+
+# End of file

data/lib/rley.rb

@@ -4,6 +4,10 @@
 
 require_relative './rley/constants'
 require_relative './rley/syntax/grammar_builder'
+require_relative './rley/parser/token'
 require_relative './rley/parser/earley_parser'
+require_relative './rley/parse_tree_visitor'
+require_relative './rley/formatter/debug'
+require_relative './rley/formatter/json'
 
 # End of file

data/lib/rley/constants.rb

@@ -3,7 +3,7 @@
 
 module Rley # Module used as a namespace
   # The version number of the gem.
-  Version = '0.1.09'
+  Version = '0.1.10'
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.1.09
+  version: 0.1.10
 platform: ruby
 authors:
 - Dimitri Geshef
@@ -101,6 +101,8 @@ files:
 - README.md
 - examples/grammars/grammar_abc.rb
 - examples/grammars/grammar_L0.rb
+- examples/parsers/parsing_abc.rb
+- examples/recognizers/recognizer_abc.rb
 - lib/rley.rb
 - lib/rley/constants.rb
 - lib/rley/formatter/base_formatter.rb