rley 0.5.08 → 0.5.09

data/examples/general/SRL/spec/regex/character_spec.rb

@@ -0,0 +1,159 @@
+# File: character_spec.rb
+require_relative '../spec_helper'	# Use the RSpec test framework
+require_relative '../../lib/regex/character'
+
+module Regex 	# Open this namespace, to get rid of scope qualifiers
+
+describe Character do
+	# This constant holds an arbitrary selection of characters
+	SampleChars = [?a, ?\0, ?\u0107]
+	
+	# This constant holds the codepoints of the character selection
+	SampleInts = [0x61, 0, 0x0107]
+
+	# This constant holds an arbitrary selection of two characters (digrams) escape sequences
+	SampleDigrams = %w[ \n \e \0 \6 \k]
+	
+	# This constant holds an arbitrary selection of escaped octal or hexadecimal literals
+	SampleNumEscs = %w[ \0 \07 \x07 \xa \x0F \u03a3 \u{a}]
+
+	before(:all) do
+		# Ensure that the set of codepoints is mapping the set of chars...
+		expect(SampleChars.map(&:ord)).to eq(SampleInts)
+	end
+	
+	context 'Creation & initialization' do
+		it 'should be created with a with an integer value (codepoint) or...' do
+			SampleInts.each do |aCodepoint|
+				expect { Character.new(aCodepoint) }.not_to raise_error
+			end
+		end		
+	
+		it '...could be created with a single character String or...' do
+			SampleChars.each do |aChar|
+				expect { Character.new(aChar) }.not_to raise_error
+			end
+		end
+		
+		it '...could be created with an escape sequence' do
+			# Case 1: escape sequence is a digram
+			SampleDigrams.each do |anEscapeSeq|
+				expect { Character.new(anEscapeSeq) }.not_to raise_error
+			end
+			
+			# Case 2: escape sequence is an escaped octal or hexadecimal literal
+			SampleNumEscs.each do |anEscapeSeq|
+				expect { Character.new(anEscapeSeq) }.not_to raise_error
+			end
+		end
+	
+	end # context
+	
+	context 'Provided services' do
+		it 'Should know its lexeme if created from a string' do
+			# Lexeme is defined when the character was initialised from a text
+			SampleChars.each do |aChar|
+				ch = Character.new(aChar)
+				expect(ch.lexeme).to eq(aChar)
+			end			
+		end
+		
+		it 'Should not know its lexeme representation if created from a codepoint' do
+			SampleInts.each do |aChar|
+				ch = Character.new(aChar)
+				expect(ch.lexeme).to be_nil
+			end			
+		end
+		
+		it 'should know its String representation' do
+			# Try for one character
+			newOne = Character.new(?\u03a3)
+			expect(newOne.char).to eq('Σ')
+			expect(newOne.to_str).to eq("\u03A3")
+			
+			# Try with our chars sample
+			SampleChars.each { |aChar| Character.new(aChar).to_str == aChar }
+			
+			# Try with our codepoint sample
+			mapped_chars = SampleInts.map { |aCodepoint| Character.new(aCodepoint).char }
+			expect(mapped_chars).to eq(SampleChars)
+			
+			# Try with our escape sequence samples
+			(SampleDigrams + SampleNumEscs).each do |anEscSeq|
+				Character.new(anEscSeq).to_str == String::class_eval(%Q|"#{anEscSeq}"|)
+			end
+		end
+		
+		it 'should know its codepoint' do
+			# Try for one character
+			newOne = Character.new(?\u03a3)
+			expect(newOne.codepoint).to eq(0x03a3)
+			
+			# Try with our chars sample
+			allCodepoints = SampleChars.map { |aChar| Character.new(aChar).codepoint }
+			expect(allCodepoints).to eq(SampleInts)
+			
+			# Try with our codepoint sample
+			mapped_chars = SampleInts.each { |aCodepoint| expect(Character.new(aCodepoint).codepoint).to eq(aCodepoint) }
+			
+			# Try with our escape sequence samples
+			(SampleDigrams + SampleNumEscs).each do |anEscSeq| 
+				expect(Character.new(anEscSeq).codepoint).to eq(String::class_eval(%Q|"#{anEscSeq}".ord()|))
+			end	
+		end	
+		
+		it 'should known whether it is equal to another Object' do
+			newOne = Character.new(?\u03a3)
+			
+			# Case 1: test equality with itself
+			expect(newOne).to eq(newOne)
+			
+			# Case 2: test equality with another Character
+			expect(newOne).to eq(Character.new(?\u03a3))
+			expect(newOne).not_to eq(Character.new(?\u0333))
+			
+			# Case 3: test equality with an integer value (equality based on codepoint value)
+			expect(newOne).to eq(0x03a3)
+			expect(newOne).not_to eq(0x0333)
+			
+			# Case 4: test equality with a single-character String
+			expect(newOne).to eq(?\u03a3)
+			expect(newOne).not_to eq(?\u0333)
+			
+			# Case 5: test fails with multiple character strings
+			expect(newOne).not_to eq('03a3')
+			
+			# Case 6: equality testing with arbitray object
+			expect(newOne).not_to eq(nil)
+			expect(newOne).not_to eq(Object.new)
+			
+			# In case 6, equality is based on to_s method.
+			simulator = double('fake')
+			expect(simulator).to receive(:to_s).and_return(?\u03a3)
+			expect(newOne).to eq(simulator)
+			
+			# Create a module that re-defines the existing to_s method
+			module Tweak_to_s
+				def to_s()	# Overwrite the existing to_s method
+					return ?\u03a3
+				end
+			end # module
+			weird = Object.new
+			weird.extend(Tweak_to_s)
+			expect(newOne).to eq(weird)
+		end
+		
+		it "should know its readable description" do
+			ch1 = Character.new('a')
+			expect(ch1.explain).to eq("the character 'a'")
+			
+			ch2 = Character.new(?\u03a3)
+			expect(ch2.explain).to eq("the character '\u03a3'")
+		end
+	end # context
+
+end # describe
+
+end # module
+
+# End of file

data/examples/general/SRL/spec/tokenizer_spec.rb

@@ -57,18 +57,32 @@ module SRL
         subject.scanner.string = ' 1 '
         token = subject.tokens.first
         expect(token).to be_kind_of(Rley::Lexical::Token)
-        expect(token.terminal.name).to eq('DIGIT')
+        expect(token.terminal.name).to eq('DIGIT_LIT')
         expect(token.lexeme).to eq('1')
       end       
     end # context
     
+    context 'Character range tokenization:' do
+      it "should recognize 'letter from ... to ...'" do
+        input = 'letter a to f'
+        subject.scanner.string = input
+        expectations = [
+          ['LETTER', 'letter'],
+          ['LETTER_LIT', 'a'],
+          ['TO', 'to'],
+          ['LETTER_LIT', 'f']
+        ]
+        match_expectations(subject, expectations)
+      end    
+    end # context
+    
     context 'Quantifier tokenization:' do
       it "should recognize 'exactly ... times'" do
         input = 'exactly 4 Times'
         subject.scanner.string = input
         expectations = [
           ['EXACTLY', 'exactly'],
-          ['DIGIT', '4'],
+          ['DIGIT_LIT', '4'],
           ['TIMES', 'Times']
         ]
         match_expectations(subject, expectations)
@@ -79,9 +93,9 @@ module SRL
         subject.scanner.string = input
         expectations = [
           ['BETWEEN', 'Between'],
-          ['DIGIT', '2'],
+          ['DIGIT_LIT', '2'],
           ['AND', 'AND'],
-          ['DIGIT', '4'],
+          ['DIGIT_LIT', '4'],
           ['TIMES', 'times']
         ]
         match_expectations(subject, expectations)

data/examples/general/SRL/srl_demo.rb

@@ -1,4 +1,5 @@
 require_relative './lib/parser'
+require_relative './lib/ast_builder'
 
 def print_title(aTitle)
   puts aTitle
@@ -28,13 +29,13 @@ Simple Regex Language parser:
 - Parses a very limited subset of the language and displays the parse tree
 
 Command-line syntax:
-  ruby #{my_name} "quantifier expression"
+  ruby #{my_name} "SRL expression"
   where:
-    the SRL quantifier expression is enclosed between double quotes (")
+    the SRL expression is enclosed between double quotes (")
 
   Examples:
-  ruby #{my_name} "exactly 4 times"
-  ruby #{my_name} "between 2 and 3 times"
+  ruby #{my_name} "letter from a to f exactly 4 times"
+  ruby #{my_name} "uppercase letter between 2 and 3 times"
 END_MSG
   puts msg
   exit(1)
@@ -54,4 +55,13 @@ end
 cst_ptree = result.parse_tree
 print_tree('Concrete Syntax Tree (CST)', cst_ptree)
 
+# Generate a regexp literal representation from the parse result
+tree_builder = ASTBuilder
+ast_ptree = result.parse_tree(tree_builder)
+
+# Now output the regexp literal
+root = ast_ptree.root
+print_title('SRL to Regexp representation:')
+puts "#{ARGV[0]} => #{root.to_str}" # Output the expression result
+
 # 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.5.08'.freeze
+  Version = '0.5.09'.freeze
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm".freeze

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.5.08
+  version: 0.5.09
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-28 00:00:00.000000000 Z
+date: 2017-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coveralls
@@ -146,11 +146,22 @@ files:
 - examples/general/SRL/lib/ast_building.rb
 - examples/general/SRL/lib/grammar.rb
 - examples/general/SRL/lib/parser.rb
+- examples/general/SRL/lib/regex/abstract_method.rb
+- examples/general/SRL/lib/regex/atomic_expression.rb
+- examples/general/SRL/lib/regex/char_class.rb
+- examples/general/SRL/lib/regex/char_range.rb
+- examples/general/SRL/lib/regex/character.rb
+- examples/general/SRL/lib/regex/compound_expression.rb
+- examples/general/SRL/lib/regex/expression.rb
+- examples/general/SRL/lib/regex/monadic_expression.rb
 - examples/general/SRL/lib/regex/multiplicity.rb
+- examples/general/SRL/lib/regex/polyadic_expression.rb
+- examples/general/SRL/lib/regex/quantifiable.rb
+- examples/general/SRL/lib/regex/repetition.rb
 - examples/general/SRL/lib/regex_repr.rb
-- examples/general/SRL/lib/srl_demo.rb
 - examples/general/SRL/lib/tokenizer.rb
 - examples/general/SRL/spec/integration_spec.rb
+- examples/general/SRL/spec/regex/character_spec.rb
 - examples/general/SRL/spec/regex/multiplicity_spec.rb
 - examples/general/SRL/spec/spec_helper.rb
 - examples/general/SRL/spec/tokenizer_spec.rb

data/examples/general/SRL/lib/srl_demo.rb

@@ -1,67 +0,0 @@
-require_relative 'parser'
-require_relative 'ast_builder'
-
-def print_title(aTitle)
-  puts aTitle
-  puts '=' * aTitle.size
-end
-
-def print_tree(aTitle, aParseTree)
-  # Let's create a parse tree visitor
-  visitor = Rley::ParseTreeVisitor.new(aParseTree)
-
-  # Now output formatted parse tree
-  print_title(aTitle)
-  renderer = Rley::Formatter::Asciitree.new($stdout)
-  renderer.render(visitor)
-  puts ''
-end
-
-# Create a calculator parser object
-parser = SRL::Parser.new
-
-# Parse the input expression in command-line
-if ARGV.empty?
-  my_name = File.basename(__FILE__)
-  msg = <<-END_MSG
-Demo parser for the SRL, the Simple Regex Language (https://simple-regex.com/).
-Ultimately it will support SRL in full, currently it parses only the 
-SRL quantifiers.
-The utility prints the resulting regular expression.
-
-Command-line syntax:
-  ruby #{my_name} filename
-  where:
-    the file name is a SRL source file.
-
-  Examples:
-  ruby #{my_name} sample01.srl
-END_MSG
-  puts msg
-  exit(1)
-end
-puts ARGV[0]
-result = parser.parse_expression(ARGV[0])
-
-unless result.success?
-  # Stop if the parse failed...
-  puts "Parsing of '#{ARGV[0]}' failed"
-  puts "Reason: #{result.failure_reason.message}"
-  exit(1)
-end
-
-
-# Generate a concrete syntax parse tree from the parse result
-cst_ptree = result.parse_tree
-print_tree('Concrete Syntax Tree (CST)', cst_ptree)
-
-# Generate an abstract syntax parse tree from the parse result
-tree_builder = ASTBuilder
-ast_ptree = result.parse_tree(tree_builder)
-# print_tree('Abstract Syntax Tree (AST)', ast_ptree)
-
-# # Now perform the computation of math expression
-# root = ast_ptree.root
-# print_title('Result:')
-# puts root.interpret.to_s # Output the expression result
-# End of file