rley 0.5.08 → 0.5.09

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

@@ -0,0 +1,60 @@
+# File: compound_expression.rb
+
+require_relative "expression"	# Access the superclass
+
+module Regex # This module is used as a namespace
+
+# Abstract class. An element that is part of a regular expression &  
+# that has its own child sub-expressions.
+class CompoundExpression < Expression
+	
+public
+	# Redefined method. Return false since it may have one or more children.
+	def atomic? 
+		return false
+	end
+	
+=begin	
+	# Build a depth-first in-order children visitor.
+	# The visitor is implemented as an Enumerator.
+	def df_visitor()
+		root = children	# The visit will start from the children of this object
+		
+		visitor = Enumerator.new do |result|	# result is a Yielder
+			# Initialization part: will run once
+			visit_stack = [ root ]	# The LIFO queue of nodes to visit
+			
+			begin	# Traversal part (as a loop)
+				top = visit_stack.pop()
+				if top.kind_of?(Array)
+					if top.empty?
+						next
+					else
+						currChild = top.pop()
+						visit_stack.push top					
+					end
+				else
+					currChild = top
+				end
+				
+				result << currChild		# Return the visited child
+				
+				unless currChild.atomic?
+					children_to_enqueue = currChild.children.reverse()	# in-order traversal implies LIFO queue
+					visit_stack.push(children_to_enqueue)
+				end			
+			end until visit_stack.empty?
+		end
+	end
+=end
+
+protected
+	# Abstract method. Return the text representation of the child (if any)
+	def all_child_text() abstract_method()
+	end
+
+end # class
+
+end # module
+
+# End of file

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

@@ -0,0 +1,42 @@
+# File: expression.rb
+
+require_relative 'abstract_method'
+
+module Regex # This module is used as a namespace
+
+# Abstract class. The generalization of any valid regular (sub)expression.
+class Expression	
+	def initialize()
+	end
+	
+public
+	# Abstract method. Return true iff the expression is atomic (= may not have any child).
+	def atomic? abstract_method
+	end
+
+	# Abstract method. Return the number of values that match this expression.
+	# [theParentOptions] an Hash of matching options. They are overridden by options with same name
+	# that are bound to this object.
+	def cardinality(theParentOptions) abstract_method
+	end
+
+protected
+	# Determine the matching options to apply to this object, given the options coming from the parent
+	# and options that are local to this object. Local options take precedence.
+	# [theParentOptions] a Hash of matching options. They are overridden by options with same name
+	# that are bound to this object.
+	def options(theParentOptions)
+		resulting_options = theParentOptions.merge(@local_options)
+		return resulting_options
+	end
+	
+	# Abstract conversion method. 
+	# Purpose: Return the String representation of the expression.
+	def to_str() abstract_method
+	end
+
+end # class
+
+end # module
+
+# End of file

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

@@ -0,0 +1,31 @@
+# File: monadic_expression.rb
+
+require_relative "compound_expression"	# Access the superclass
+
+module Regex # This module is used as a namespace
+
+# Abstract class. An element that is part of a regular expression &  
+# that can have up to one child sub-expression.
+class MonadicExpression < CompoundExpression
+	# The (optional) child sub-expression
+	attr_reader(:child)
+	
+	# Constructor.
+	def initialize(theChild)
+		super()	
+		@child = theChild
+	end
+	
+protected
+	# Return the text representation of the child (if any)
+	def all_child_text()
+		result = child.nil? ? '' : child.to_str()
+		
+		return result
+	end
+
+end # class
+
+end # module
+
+# End of file

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

@@ -0,0 +1,64 @@
+# File: polyadic_expression.rb
+
+require_relative "compound_expression"	# Access the superclass
+
+module Regex # This module is used as a namespace
+
+# Abstract class. An element that is part of a regular expression &  
+# that has its own child sub-expressions.
+class PolyadicExpression < CompoundExpression
+	# The aggregation of child elements
+	attr_reader(:children)
+	
+	# Constructor.
+	def initialize(theChildren)
+		super()	
+		@children = theChildren
+	end
+	
+public
+	# Append the given child to the list of children.
+	# TODO: assess whether to defer to a subclass NAryExpression
+	def <<(aChild)
+		@children << aChild
+		
+		return self
+	end
+	
+	# Build a depth-first in-order children visitor.
+	# The visitor is implemented as an Enumerator.
+	def df_visitor()
+		root = children	# The visit will start from the children of this object
+		
+		visitor = Enumerator.new do |result|	# result is a Yielder
+			# Initialization part: will run once
+			visit_stack = [ root ]	# The LIFO queue of nodes to visit
+			
+			begin	# Traversal part (as a loop)
+				top = visit_stack.pop()
+				if top.kind_of?(Array)
+					if top.empty?
+						next
+					else
+						currChild = top.pop()
+						visit_stack.push top					
+					end
+				else
+					currChild = top
+				end
+				
+				result << currChild		# Return the visited child
+				
+				unless currChild.atomic?
+					children_to_enqueue = currChild.children.reverse()	# in-order traversal implies LIFO queue
+					visit_stack.push(children_to_enqueue)
+				end			
+			end until visit_stack.empty?
+		end
+	end
+
+end # class
+
+end # module
+
+# End of file

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

@@ -0,0 +1,28 @@
+# File: quantifiable.rb
+
+require_relative 'multiplicity'	
+
+module Regex # This module is used as a namespace
+
+
+module Quantifiable
+
+public
+	# Redefined method. Return true since it may not have any child.
+	def quantified?
+		return @quantifier.nil? ? false :true
+	end
+  
+  def quantifier
+    @quantifier
+  end
+  
+  def quantifier=(aQuantifier)
+    @quantifier = aQuantifier
+  end
+	
+end # class
+	
+end # module
+
+# End of file

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

@@ -0,0 +1,31 @@
+# File: repetition.rb
+
+require_relative "monadic_expression"	# Access the superclass
+
+module Regex # This module is used as a namespace
+
+# Abstract class. An unary matching operator. 
+# It succeeds when the specified reptition of the child expression succeeds to match 
+# the subject text in the same serial arrangement
+class Repetition < MonadicExpression
+	attr_reader(:multiplicity)
+	
+	# Constructor.
+	def initialize(childExpressionToRepeat, aMultiplicity)
+		super(childExpressionToRepeat)
+		@multiplicity = aMultiplicity
+	end
+	
+public
+	# Conversion method re-definition.
+	# Purpose: Return the String representation of the concatented expressions.
+	def to_str()
+		result = all_child_text() + multiplicity.to_str()
+		return result
+	end
+
+end # class
+
+end # module
+
+# End of file

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

@@ -1 +1,5 @@
-require_relative './regex/multiplicity'
+require_relative './regex/character'
+require_relative './regex/char_range'
+require_relative './regex/multiplicity'
+require_relative './regex/repetition'
+require_relative './regex/char_class'

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

@@ -29,14 +29,18 @@ module SRL
       AT
       BETWEEN
       EXACTLY
+      FROM
       LEAST
+      LETTER
       MORE
       NEVER
       ONCE
       OPTIONAL
       OR
       TIMES
+      TO
       TWICE
+      UPPERCASE
     ].map { |x| [x, x] } .to_h
     
     class ScanError < StandardError; end
@@ -67,18 +71,17 @@ module SRL
       token = nil
 
       if '(),'.include? curr_ch
-        # Single character token
+        # Delimiters, separators => single character token
         token = build_token(@@lexeme2name[curr_ch], scanner.getch)  
       elsif (lexeme = scanner.scan(/[0-9]{2,}/))
         token = build_token('INTEGER', lexeme) # An integer has two or more digits
       elsif (lexeme = scanner.scan(/[0-9]/))
-        token = build_token('DIGIT', lexeme) 
+        token = build_token('DIGIT_LIT', lexeme) 
       elsif (lexeme = scanner.scan(/[a-zA-Z]{2,}/))
         token = build_token(@@keywords[lexeme.upcase], lexeme)
         # TODO: handle case unknown identifier
-      elsif (lexeme = scanner.scan(/\w/))
-        puts 'Buff'
-        token = build_token('CHAR', lexeme)      
+      elsif (lexeme = scanner.scan(/[a-zA-Z]((?=\s)|$)/))
+        token = build_token('LETTER_LIT', lexeme)      
       else # Unknown token
         erroneous = curr_ch.nil? ? '' : curr_ch
         sequel = scanner.scan(/.{1,20}/)

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

@@ -15,89 +15,112 @@ describe 'Integration tests:' do
     regexp = tree.root
   end
 
+  context 'Parsing character ranges:' do
+    it "should parse 'letter from ... to ...' syntax" do
+      result = parse('letter from a to f')
+      expect(result).to be_success
+
+      regexp = regexp_repr(result)
+      expect(regexp.to_str).to eq('[a-f]')
+    end
+
+    it "should parse 'uppercase letter from ... to ...' syntax" do
+      result = parse('UPPERCASE letter from A to F')
+      expect(result).to be_success
+
+      regexp = regexp_repr(result)
+      expect(regexp.to_str).to eq('[A-F]')
+    end
+
+    it "should parse 'letter' syntax" do
+      result = parse('letter')
+      expect(result).to be_success
+
+      regexp = regexp_repr(result)
+      expect(regexp.to_str).to eq('[a-z]')
+    end
+
+    it "should parse 'uppercase letter' syntax" do
+      result = parse('uppercase letter')
+      expect(result).to be_success
+
+      regexp = regexp_repr(result)
+      expect(regexp.to_str).to eq('[A-Z]')
+    end
+
+  end # context
+
   context 'Parsing quantifiers:' do
+    let(:prefix) { 'letter from p to t ' }
+
     it "should parse 'once' syntax" do
-      result = parse('once')
+      result = parse(prefix + 'once')
       expect(result).to be_success
 
       regexp = regexp_repr(result)
-      expect(regexp.to_str).to eq('{1}')
+      expect(regexp.to_str).to eq('[p-t]{1}')
     end
 
     it "should parse 'twice' syntax" do
-      result = parse('twice')
+      result = parse(prefix + 'twice')
       expect(result).to be_success
-      
+
       regexp = regexp_repr(result)
-      expect(regexp.to_str).to eq('{2}')      
+      expect(regexp.to_str).to eq('[p-t]{2}')
     end
 
     it "should parse 'optional' syntax" do
-      result = parse('optional')
+      result = parse(prefix + 'optional')
       expect(result).to be_success
-      
+
       regexp = regexp_repr(result)
-      expect(regexp.to_str).to eq('?')      
+      expect(regexp.to_str).to eq('[p-t]?')
     end
 
     it "should parse 'exactly ... times' syntax" do
-      result = parse('exactly 4 times')
+      result = parse('letter from a to f exactly 4 times')
       expect(result).to be_success
-      
+
       regexp = regexp_repr(result)
-      expect(regexp.to_str).to eq('{4}')        
+      expect(regexp.to_str).to eq('[a-f]{4}')
     end
 
     it "should parse 'between ... and ... times' syntax" do
-      result = parse('between 2 and 4 times')
+      result = parse(prefix + 'between 2 and 4 times')
       expect(result).to be_success
 
       # Dropping 'times' keyword is shorter syntax
-      expect(parse('between 2 and 4')).to be_success
-      
+      expect(parse(prefix + 'between 2 and 4')).to be_success
+
       regexp = regexp_repr(result)
-      expect(regexp.to_str).to eq('{2, 4}')        
+      expect(regexp.to_str).to eq('[p-t]{2,4}')
     end
 
+
     it "should parse 'once or more' syntax" do
-      result = parse('once or more')
+      result = parse(prefix + 'once or more')
       expect(result).to be_success
+
+      regexp = regexp_repr(result)
+      expect(regexp.to_str).to eq('[p-t]+')
     end
 
     it "should parse 'never or more' syntax" do
-      result = parse('never or more')
+      result = parse(prefix + 'never or more')
       expect(result).to be_success
+
+      regexp = regexp_repr(result)
+      expect(regexp.to_str).to eq('[p-t]*')
     end
 
     it "should parse 'at least  ... times' syntax" do
-      result = parse('at least 10 times')
+      result = parse(prefix + 'at least 10 times')
       expect(result).to be_success
-      
+
       regexp = regexp_repr(result)
-      expect(regexp.to_str).to eq('{10,}')      
+      expect(regexp.to_str).to eq('[p-t]{10,}')
     end
-
   end # context
-
 end # describe
 
 
-=begin
-
-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)
-=end
-