rley 0.5.08 → 0.5.09

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c616b691fb51ba2eb00a25fee75ff4a80093990
-  data.tar.gz: 1039cfe8f29c8d1ec7c88fa83c18f9173763b8f2
+  metadata.gz: d95e1ed6a38d8e1ed70e456f46c812275a1d4530
+  data.tar.gz: fcf7b54ff98d107fa38239139db10e7bbf1f7825
 SHA512:
-  metadata.gz: df7412344421bd421fb459fe5cf8053618dea1212c4da27e83cf41225dbaf664d9b143499978e6bcef2ae293a7bf9378d3ecb4867f989553f798e9723ba8344b
-  data.tar.gz: 436474ceafd2689137fab890b19ca24715ebe72dd1311b3ad64313bc130cf8bbce12fe35049008d20a89634309cbac882da70bc891522d45a58e8ce310b466a7
+  metadata.gz: e185aa4e7ca59e5995f6e87379efd4f921d4242307abd55718e46bf346e7414c487b56f753f446d8518ffab74e783774aaa2adc9b7fcf8a014fdba96b8da090d
+  data.tar.gz: 5c990777d79432c813c92dda0b21e7af3dcf587485b868e9723d30e3d1c1b3b2d6e1bc8dc7235fb1ba32c1b27ddeb6f829ef3e1b7b9248d5be1199f27e153849

data/CHANGELOG.md

@@ -1,4 +1,10 @@
-### 0.5.08 / 2017-11-xx
+### 0.5.09 / 2017-12-02
+* [CHANGE] Dir `examples/general/SRL/ Added support for letter range to Simple Regex Language parser.
+
+### 0.5.08 / 2017-11-28
+* [NEW] Dir `examples/general/SRL/ Added an initial version of the Simple Regex Language parser.
+  Supports the SRL quantifier syntax only.
+* [FIX] Method `ParseTreeBuilder::place_TOS_child` was sometimes fooled when argument `aNode` was nil.
 * [FIX] Method `BaseParser::initialize` missing parameter name in doc caused a YARD warning.
 * [FIX] Method `GrmItemsBuilder::build_dotted_items` missing parameter name in doc caused a YARD warning.
 * [FIX] Method `NonTerminalVertex::initialize` missing parameter name in doc caused a YARD warning.

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

@@ -35,9 +35,30 @@ class ASTBuilder < Rley::Parser::ParseTreeBuilder
   # @param theChildren [Array] Children nodes (one per rhs symbol)
   def new_parent_node(aProduction, aRange, theTokens, theChildren)
     node = case aProduction.name
-      when 'srl_0' # rule 'srl' => 'quantifier'
+      when 'srl_0' # rule 'srl' => 'term'
         return_first_child(aRange, theTokens, theChildren)
 
+      when 'term_0' # rule 'term' => 'atom'
+        return_first_child(aRange, theTokens, theChildren)
+
+      when 'term_1' # rule 'term' => %w[atom quantifier]
+        reduce_term_1(aProduction, aRange, theTokens, theChildren)
+
+      when 'atom_0' #rule 'atom' => 'letter_range'
+        return_first_child(aRange, theTokens, theChildren)
+
+      when 'letter_range_0' # rule 'letter_range' => %w[LETTER FROM LETTER_LIT TO LETTER_LIT]
+        reduce_letter_range_0(aProduction, aRange, theTokens, theChildren)
+        
+       when 'letter_range_1' #rule 'letter_range' => %w[UPPERCASE LETTER FROM LETTER_LIT TO LETTER_LIT]
+        reduce_letter_range_1(aProduction, aRange, theTokens, theChildren)
+        
+      when 'letter_range_2' # rule 'letter_range' => 'LETTER'
+        reduce_letter_range_2(aProduction, aRange, theTokens, theChildren)
+
+      when 'letter_range_3' # rule 'letter_range' => %w[UPPERCASE LETTER]
+        reduce_letter_range_3(aProduction, aRange, theTokens, theChildren)        
+
       when 'quantifier_0' # rule 'quantifier' => 'ONCE'
         multiplicity(1, 1)
 
@@ -78,99 +99,74 @@ class ASTBuilder < Rley::Parser::ParseTreeBuilder
     return SRL::Regex::Multiplicity.new(lowerBound, upperBound, :greedy)
   end
 
-  # rule 'quantifier' => %w[EXACTLY count TIMES]
-  def reduce_quantifier_2(aProduction, aRange, theTokens, theChildren)
-    count = theChildren[1].token.lexeme.to_i
-    multiplicity(count, count)
-  end
-
-  # rule 'quantifier' => %w[BETWEEN count AND count times_suffix]
-  def reduce_quantifier_3(aProduction, aRange, theTokens, theChildren)
-    upper = theChildren[3].token.lexeme.to_i
-    # lower = theChildren[1].token.lexeme.to_i
-    multiplicity(3, upper)
-  end
-
-  # rule 'quantifier' => %w[AT LEAST count TIMES]
-  def reduce_quantifier_7(aProduction, aRange, theTokens, theChildren)
-    count = theChildren[2].token.lexeme.to_i
-    multiplicity(count, :more)
+  def char_range(lowerBound, upperBound)
+    # TODO fix module nesting  
+    lower = Regex::Character.new(lowerBound)
+    upper =  Regex::Character.new(upperBound)
+    return Regex::CharRange.new(lower, upper)
   end
-
-
-=begin
-  def reduce_binary_operator(theChildren)
-    operator_node = theChildren[1]
-    operator_node.children << theChildren[0]
-    operator_node.children << theChildren[2]
-    return operator_node
+  
+  def char_class(toNegate, *theChildren)
+    Regex::CharClass.new(toNegate, *theChildren)
   end
-
-  # rule 'simple_expression' => %w[simple_expression add_operator term]
-  def reduce_simple_expression_1(_production, _range, _tokens, theChildren)
-    reduce_binary_operator(theChildren)
+  
+  def repetition(expressionToRepeat, aMultiplicity)
+    return Regex::Repetition.new(expressionToRepeat, aMultiplicity)
   end
 
-  # rule 'term' => %w[term mul_operator factor]
-  def reduce_term_1(_production, _range, _tokens, theChildren)
-    reduce_binary_operator(theChildren)
+  # rule 'term' => %w[atom quantifier]
+  def reduce_term_1(aProduction, aRange, theTokens, theChildren)
+    quantifier = theChildren.last
+    atom = theChildren.first
+    repetition(atom, quantifier)
   end
 
-  # rule 'factor' => %w[simple_factor POWER simple_factor]]
-  def reduce_factor_1(aProduction, aRange, theTokens, theChildren)
-    result = PowerNode.new(theChildren[1].symbol, aRange)
-    result.children << theChildren[0]
-    result.children << theChildren[2]
-
-    return result
+  # rule 'letter_range' => %w[LETTER FROM LETTER_LIT TO LETTER_LIT]
+  def reduce_letter_range_0(aProduction, aRange, theTokens, theChildren)
+    lower = theChildren[2].token.lexeme
+    upper =  theChildren[4].token.lexeme
+    ch_range = char_range(lower, upper)
+    char_class(false, ch_range)
   end
-
-  # rule 'simple_factor' => %[sign scalar]
-  def reduce_simple_factor_0(aProduction, aRange, theTokens, theChildren)
-    first_child = theChildren[0]
-    result = if first_child.kind_of?(CalcNegateNode)
-               -theChildren[1]
-             else
-               theChildren[1]
-             end
-
-    return result
+  
+  # rule 'letter_range' => %w[UPPERCASE LETTER FROM LETTER_LIT TO LETTER_LIT]
+  def reduce_letter_range_1(aProduction, aRange, theTokens, theChildren)
+    lower = theChildren[3].token.lexeme
+    upper =  theChildren[5].token.lexeme
+    ch_range = char_range(lower.upcase, upper.upcase)
+    char_class(false, ch_range)
   end
-
-  # rule 'simple_factor' => %w[unary_function in_parenthesis]
-  def reduce_simple_factor_1(aProduction, aRange, theTokens, theChildren)
-    func = CalcUnaryFunction.new(theChildren[0].symbol, aRange.low)
-    func.func_name = theChildren[0].value
-    func.children << theChildren[1]
-    return func
+  
+  # rule 'letter_range' => 'LETTER'
+  def reduce_letter_range_2(aProduction, aRange, theTokens, theChildren)
+    ch_range = char_range('a', 'z')
+    char_class(false, ch_range)  
   end
-
-  # rule 'simple_factor' => %w[MINUS in_parenthesis]
-  def reduce_simple_factor_2(aProduction, aRange, theTokens, theChildren)
-    negation = CalcNegateNode.new(theChildren[0].symbol, aRange.low)
-    negation.children << theChildren[1]
-    return negation
+  
+  #rule 'letter_range' => %w[UPPERCASE LETTER]
+  def reduce_letter_range_3(aProduction, aRange, theTokens, theChildren)
+    ch_range = char_range('A', 'Z')
+    char_class(false, ch_range)    
   end
 
-  # rule 'add_operator' => 'PLUS'
-  def reduce_add_operator_0(_production, aRange, _tokens, theChildren)
-    return CalcAddNode.new(theChildren[0].symbol, aRange)
+  # rule 'quantifier' => %w[EXACTLY count TIMES]
+  def reduce_quantifier_2(aProduction, aRange, theTokens, theChildren)
+    count = theChildren[1].token.lexeme.to_i
+    multiplicity(count, count)
   end
 
-  # rule 'add_operator' => 'MINUS'
-  def reduce_add_operator_1(_production, aRange, _tokens, theChildren)
-    return CalcSubtractNode.new(theChildren[0].symbol, aRange)
+  # rule 'quantifier' => %w[BETWEEN count AND count times_suffix]
+  def reduce_quantifier_3(aProduction, aRange, theTokens, theChildren)
+    lower = theChildren[1].token.lexeme.to_i
+    upper = theChildren[3].token.lexeme.to_i
+    multiplicity(lower, upper)
   end
 
-  # rule 'mul_operator' => 'STAR'
-  def reduce_mul_operator_0(_production, aRange, _tokens, theChildren)
-    return CalcMultiplyNode.new(theChildren[0].symbol, aRange)
+  # rule 'quantifier' => %w[AT LEAST count TIMES]
+  def reduce_quantifier_7(aProduction, aRange, theTokens, theChildren)
+    count = theChildren[2].token.lexeme.to_i
+    multiplicity(count, :more)
   end
 
-  # rule 'mul_operator' => 'DIVIDE'
-  def reduce_mul_operator_1(_production, aRange, _tokens, theChildren)
-    return CalcDivideNode.new(theChildren[0].symbol, aRange)
-  end
-=end
 end # class
 # End of file

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

@@ -6,13 +6,21 @@ module SRL
   # This is a very partial grammar of SRL.
   # It will be expanded with the coming versions of Rley
   builder = Rley::Syntax::GrammarBuilder.new do
-    add_terminals('DIGIT', 'INTEGER')
+    add_terminals('DIGIT_LIT', 'INTEGER', 'LETTER_LIT')
+    add_terminals('UPPERCASE', 'LETTER', 'FROM', 'TO')
     add_terminals('EXACTLY', 'TIMES', 'ONCE', 'TWICE')
     add_terminals('BETWEEN', 'AND', 'OPTIONAL', 'OR')
     add_terminals('MORE', 'NEVER', 'AT', 'LEAST')
 
     # For the moment one focuses on quantifier syntax only...
-    rule 'srl' => 'quantifier'
+    rule 'srl' => 'term'
+    rule 'term' => 'atom'
+    rule 'term' => %w[atom quantifier]
+    rule 'atom' => 'letter_range'
+    rule 'letter_range' => %w[LETTER FROM LETTER_LIT TO LETTER_LIT]
+    rule 'letter_range' => %w[UPPERCASE LETTER FROM LETTER_LIT TO LETTER_LIT]
+    rule 'letter_range' => 'LETTER'
+    rule 'letter_range' => %w[UPPERCASE LETTER]    
     rule 'quantifier' => 'ONCE'
     rule 'quantifier' => 'TWICE'
     rule 'quantifier' => %w[EXACTLY count TIMES]
@@ -21,7 +29,7 @@ module SRL
     rule 'quantifier' => %w[ONCE OR MORE]
     rule 'quantifier' => %w[NEVER OR MORE]
     rule 'quantifier' => %w[AT LEAST count TIMES]
-    rule 'count' => 'DIGIT'
+    rule 'count' => 'DIGIT_LIT'
     rule 'count' => 'INTEGER'
     rule 'times_suffix' => 'TIMES'
     rule 'times_suffix' => []

data/examples/general/SRL/lib/regex/abstract_method.rb

@@ -0,0 +1,35 @@
+# File: abstract_method.rb
+
+# Mix-in module. Provides the method 'abstract_method' that raises an exception
+# with an appropriate message when called.
+module AbstractMethod
+public
+	
+	# Call this method in the body of your abstract methods.
+	# Example:
+	# require 'AbstractMethod'
+	# class SomeClass
+	# include AbstractMethod # To add the behaviour from the mix-in module AbstractMethod
+	# ...
+	# Consider that SomeClass has an abstract method called 'some_method'
+	#
+	# def some_method() abstract_method
+	# end
+	def abstract_method()
+		# Determine the short class name of self
+		className =  self.class.name.split(/::/).last
+		
+		# Retrieve the top text line of the call stack
+		top_line = caller.first
+		
+		# Extract the calling method name
+		callerNameInQuotes = top_line.scan(/`.+?$/).first
+		callerName = callerNameInQuotes.gsub(/`|'/, '')	# Remove enclosing quotes
+		
+		# Build the error message
+		error_message = "The method #{className}##{callerName} is abstract. It should be implemented in subclasses of #{className}."
+		raise NotImplementedError, error_message
+	end
+end # module
+
+# End of file

data/examples/general/SRL/lib/regex/atomic_expression.rb

@@ -0,0 +1,21 @@
+# File: atomic_expression.rb
+
+require_relative "expression"	# Access the superclass
+
+module Regex # This module is used as a namespace
+
+# Abstract class. A valid regular expression that  
+# cannot be further decomposed into sub-expressions.
+class AtomicExpression < Expression
+
+public
+	# Redefined method. Return true since it may not have any child.
+	def atomic? 
+		return true
+	end
+	
+end # class
+	
+end # module
+
+# End of file

data/examples/general/SRL/lib/regex/char_class.rb

@@ -0,0 +1,34 @@
+# File: char_class.rb
+
+require_relative "polyadic_expression"	# Access the superclass
+
+module Regex # This module is used as a namespace
+
+# Abstract class. A n-ary matching operator. 
+# It succeeds when one child expression succeeds to match the subject text
+# than defined by this concatenation.
+class CharClass < PolyadicExpression
+	# A flag that indicates whether the character is negated
+	attr_reader(:negated)
+	
+	# Constructor.
+	def initialize(to_negate,*theChildren)
+		super(theChildren)
+		@negated = to_negate
+	end
+
+public
+	# Conversion method re-definition.
+	# Purpose: Return the String representation of the concatented expressions.
+	def to_str()
+		result_children = children.inject('') { |subResult, aChild| subResult << aChild.to_str() }
+		result = '['+ (negated ? '^' : '')  + result_children + ']'
+		
+		return result
+	end
+
+end # class
+
+end # module
+
+# End of file

data/examples/general/SRL/lib/regex/char_range.rb

@@ -0,0 +1,50 @@
+# File: char_range.rb
+
+require_relative 'polyadic_expression'	# Access the superclass
+
+module Regex # This module is used as a namespace
+
+# A binary expression that represents a contiguous range of characters.
+# Assumption: characters are ordered by codepoint
+class CharRange < PolyadicExpression
+	
+	# Constructor.
+	# [thelowerBound] A character that will be the lower bound value for the range.
+	# [theUpperBound] A character that will be the upper bound value for the range.
+	# TODO: optimisation. Build a Character if lower bound == upper bound.
+	def initialize(theLowerBound, theUpperBound)
+		range = validated_range(theLowerBound, theUpperBound)
+		super(range)
+	end
+
+public
+	# Return the lower bound of the range.
+	def lower()
+		return children.first
+	end
+	
+	# Return the upper bound of the range.
+	def upper()
+		return children.last
+	end	
+
+	# Conversion method re-definition.
+	# Purpose: Return the String representation of the concatented expressions.
+	def to_str()
+		result = lower.to_str() + '-' + upper.to_str()
+		
+		return result
+	end
+
+private
+	# Validation method. Returns a couple of Characters.after their validation.
+	def validated_range(theLowerBound, theUpperBound)
+		raise StandardError, "Character range error: lower bound is greater than upper bound." if theLowerBound.codepoint > theUpperBound.codepoint
+		return [theLowerBound, theUpperBound]
+	end
+
+end # class
+
+end # module
+
+# End of file

data/examples/general/SRL/lib/regex/character.rb

@@ -0,0 +1,195 @@
+# File: character.rb
+
+require_relative 'atomic_expression'	# Access the superclass
+
+module Regex # This module is used as a namespace
+
+# A regular expression that matches a specific character in a given character set
+class Character < AtomicExpression
+	# Constant with all special 2-characters escape sequences
+	DigramSequences = {
+		"\\a" => 0x7, # alarm
+		"\\n" => 0xA, # newline
+		"\\r" => 0xD, # carriage return
+		"\\t" => 0x9, # tab	
+		"\\e" => 0x1B, # escape
+		"\\f" => 0xC, # form feed
+		"\\v" => 0xB, # vertical feed
+		# Single octal digit literals
+		"\\0" => 0,
+		"\\1" => 1,
+		"\\2" => 2,
+		"\\3" => 3,
+		"\\4" => 4,
+		"\\5" => 5,	
+		"\\6" => 6,	
+		"\\7" => 7			
+	}
+	
+	# The integer value that uniquely identifies the character. 
+	attr_reader(:codepoint)
+	
+	# The initial text representation of the character (if any).
+	attr_reader(:lexeme)
+	
+	# Constructor.
+	# [aValue] Initialize the character with a either a String literal or a codepoint value.
+	# Examples:
+	# Initializing with codepoint value...
+	# RegAn::Character.new(0x3a3)	# Represents: Σ (Unicode GREEK CAPITAL LETTER SIGMA)
+	# RegAn::Character.new(931)		# Also represents: Σ (931 dec == 3a3 hex)
+	#
+	# Initializing with a single character string
+	# RegAn::Character.new(?\u03a3) # Also represents: Σ
+	# RegAn::Character.new('Σ')		# Obviously, represents a Σ
+	#
+	# Initializing with an escape sequence string
+	# Recognized escaped characters are: \a (alarm, 0x07), \n (newline, 0xA),
+	#	\r (carriage return, 0xD), \t (tab, 0x9), \e (escape, 0x1B), \f (form feed, 0xC)
+	#	\uXXXX where XXXX is a 4 hex digits integer value, \u{X...}, \ooo (octal)	\xXX (hex)
+	# Any other escaped character will be treated as a literal character
+	# RegAn::Character.new('\n')		# Represents a newline
+	# RegAn::Character.new('\u03a3')	# Represents a Σ
+	def initialize(aValue)
+
+		case aValue
+			when String
+				if aValue.size == 1
+					# Literal single character case...
+					@codepoint = self.class.char2codepoint(aValue)
+				else
+					# Should be an escape sequence...
+					@codepoint = self.class.esc2codepoint(aValue)
+				end
+				@lexeme = aValue
+				
+			when Fixnum
+				@codepoint = aValue
+			else
+				raise StandardError, "Cannot initialize a Character with a '#{aValue}'."
+		end
+	end
+	
+public
+	# Convertion method that returns a character given a codepoint (integer) value.
+	# Example:
+	# RegAn::Character::codepoint2char(0x3a3)	# Returns: Σ (The Unicode GREEK CAPITAL LETTER SIGMA)
+	def self.codepoint2char(aCodepoint)
+		return [aCodepoint].pack('U')	# Remark: chr() fails with codepoints > 256
+	end
+	
+	# Convertion method that returns the codepoint for the given single character.
+	# Example:
+	# RegAn::Character::char2codepoint('Σ')	# Returns: 0x3a3	
+	def self.char2codepoint(aChar)
+		return aChar.ord()		
+	end
+	
+	# Convertion method that returns the codepoint for the given escape sequence (a String).
+	# Recognized escaped characters are: \a (alarm, 0x07), \n (newline, 0xA),
+	#	\r (carriage return, 0xD), \t (tab, 0x9), \e (escape, 0x1B), \f (form feed, 0xC), \v (vertical feed, 0xB)
+	#	\uXXXX where XXXX is a 4 hex digits integer value, \u{X...}, \ooo (octal)	\xXX (hex)
+	# Any other escaped character will be treated as a literal character	
+	# Example:
+	# RegAn::Character::esc2codepoint('\n')	# Returns: 0xd	
+	def self.esc2codepoint(anEscapeSequence)
+		raise StandardError, "Escape sequence #{anEscapeSequence} does not begin with a backslash (\)." unless anEscapeSequence[0] == "\\"
+		result = (anEscapeSequence.length == 2)? digram2codepoint(anEscapeSequence) : esc_number2codepoint(anEscapeSequence)
+		
+		return result
+	end
+	
+	# Return the character as a String object
+	def char()
+		self.class.codepoint2char(@codepoint)
+	end
+	
+	# Conversion method re-definition.
+	# Purpose: Return the String representation of the expression.
+	# If the Character was initially from a text (the lexeme), then the lexeme is returned back.
+	# Otherwise the character corresponding to the codepoint is returned.
+	def to_str()
+		if lexeme.nil?
+			result = char()
+		else
+			result = lexeme.dup()
+		end
+		
+		return result
+	end
+	
+	# Returns true iff this Character and parameter 'another' represent the same character.
+	# [another] any Object. The way the equality is tested depends on the another's class
+	# Example:
+	# newOne = Character.new(?\u03a3)
+	# newOne == newOne	# true. Identity
+	# newOne == Character.new(?\u03a3)	# true. Both have same codepoint
+	# newOne == ?\u03a3	# true. The single character String match exactly the char attribute.
+	# newOne == 0x03a3	# true. The Fixnum is compared to the codepoint value.
+	# Will test equality with any Object that knows the to_s method
+	def ==(another)
+		result = case another
+			when Character
+				self.to_str == another.to_str
+				
+			when Fixnum
+				self.codepoint == another
+				
+			when String
+				(another.size > 1) ? false : self.to_str == another
+				
+			else
+				# Unknown type: try with a convertion
+				self == another.to_s()	# Recursive call
+		end
+		
+		return result
+	end
+	
+	# Return a plain English description of the character
+	def explain()
+		return "the character '#{to_str()}'"
+	end
+	
+private
+	# Convertion method that returns a codepoint for the given two characters (digram) escape sequence.
+	# Recognized escaped characters are: \a (alarm, 0x07), \n (newline, 0xA),
+	#	\r (carriage return, 0xD), \t (tab, 0x9), \e (escape, 0x1B), \f (form feed, 0xC), \v (vertical feed, 0xB)
+	# Any other escape sequence will return the codepoint of the escaped character.
+	# [aDigram]	A sequence of two characters that starts with a backslash.
+	def self.digram2codepoint(aDigram)
+		# Check that the digram is a special escape sequence
+		result = DigramSequences.fetch(aDigram, nil)
+		
+		# If it not a special sequence, then escaped character is considered literally (the backslash is 'dummy')
+		result = char2codepoint(aDigram[-1]) if result.nil?
+		return result
+	end
+
+	# Convertion method that returns a codepoint for the given complex escape sequence.	
+	# [anEscapeSequence] A String with the format:
+	# \uXXXX where XXXX is a 4 hex digits integer value,
+	# \u{X...} X 1 or more hex digits
+	# \ooo (1..3 octal digits literal)
+	# \xXX (1..2 hex digits literal)
+	def self.esc_number2codepoint(anEscapeSequence)
+		# Next line requires Ruby >= 1.9
+		unless /^\\(?:(?:(?<prefix>[uxX])\{?(?<hexa>\h+)\}?)|(?<octal>[0-7]{1,3}))$/ =~ anEscapeSequence
+			raise StandardError, "Unsupported escape sequence #{anEscapeSequence}." 
+		else
+			#shorterSeq = anEscapeSequence[1..-1]	# Remove the backslash
+		
+		# Octal literal case?
+			return octal.oct() if octal # shorterSeq =~ /[0-7]{1,3}/
+		
+			# Extract the hexadecimal number
+			hexliteral = hexa # shorterSeq.sub(/^[xXu]\{?([0-9a-fA-F]+)}?$/, '\1')
+			return hexliteral.hex()
+		end
+	end
+
+end # class
+
+end # module
+
+# End of file