rley 0.6.00 → 0.6.01

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

@@ -1,30 +1,27 @@
 # File: non_capturing_group.rb
 
-require_relative "monadic_expression"	# Access the superclass
+require_relative 'monadic_expression' # Access the superclass
 
 module Regex # This module is used as a namespace
-
-  # A non-capturing group, in other word it is a pure grouping of sub-expressions
+  # A non-capturing group, in other word it is a pure grouping 
+  # of sub-expressions
   class NonCapturingGroup < MonadicExpression
-    
     # Constructor.
-    # [aChildExpression]	A sub-expression to match. When successful 
+    # [aChildExpression]  A sub-expression to match. When successful
     # the matching text is assigned to the capture variable.
-    def initialize(aChildExpression)	
+    def initialize(aChildExpression)
       super(aChildExpression)
     end
-    
+
     protected
-  
+
     # Conversion method re-definition.
     # Purpose: Return the String representation of the captured expression.
     def text_repr()
-      result = '(?:' + all_child_text() + ")"
+      result = '(?:' + all_child_text + ')'
       return result
     end
-
   end # class
-
 end # module
 
-# End of file
+# End of file

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

@@ -1,64 +1,60 @@
 # File: polyadic_expression.rb
 
-require_relative "compound_expression"	# Access the superclass
+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)
 
-# 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
+    # Constructor.
+    def initialize(theChildren)
+      super()
+      @children = theChildren
+    end
 
-end # class
+    # 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)
+            next if top.empty?
+            currChild = top.pop
+            visit_stack.push top
+          else
+            currChild = top
+          end
+
+          result << currChild # Return the visited child
+
+          unless currChild.atomic?
+            # in-order traversal implies LIFO queue
+            children_to_enqueue = currChild.children.reverse
+            visit_stack.push(children_to_enqueue)
+          end
+        end until visit_stack.empty?
+      end
+      
+      return visitor
+    end
+  end # class
 end # module
 
-# End of file
+# End of file

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

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

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

@@ -1,32 +1,29 @@
 # File: repetition.rb
 
-require_relative "monadic_expression"	# Access the superclass
+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 repetition of the child expression 
+  # succeeds to match the subject text in the same serial arrangement
+  class Repetition < MonadicExpression
+    attr_reader(:multiplicity)
 
-# 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
-	
-  protected
+    # Constructor.
+    def initialize(childExpressionToRepeat, aMultiplicity)
+      super(childExpressionToRepeat)
+      @multiplicity = aMultiplicity
+    end
 
-	# Conversion method re-definition.
-	# Purpose: Return the String representation of the concatented expressions.
-	def text_repr()
-		result = all_child_text() + multiplicity.to_str()
-		return result
-	end
-
-end # class
+    protected
 
+    # Conversion method re-definition.
+    # Purpose: Return the String representation of the concatented expressions.
+    def text_repr()
+      result = all_child_text + multiplicity.to_str
+      return result
+    end
+  end # class
 end # module
 
-# End of file
+# End of file

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

@@ -1,27 +1,23 @@
 # File: wildcard.rb
 
-require_relative 'atomic_expression'	# Access the superclass
+require_relative 'atomic_expression' # Access the superclass
 
 module Regex # This module is used as a namespace
+  # A wildcard matches any character (except for the newline).
+  class Wildcard < AtomicExpression
+    # Constructor
+    def initialize()
+      super
+    end
 
-# A wildcard matches any character (except for the newline).
-class Wildcard < AtomicExpression
+    protected
 
-	# Constructor
-	def initialize()
-		super
-	end
-
-  protected
-
-	# Conversion method re-definition.
-	# Purpose: Return the String representation of the expression.
-	def text_repr()
-		return '.'
-	end
-	
-end # class
-	
+    # Conversion method re-definition.
+    # Purpose: Return the String representation of the expression.
+    def text_repr()
+      return '.'
+    end
+  end # class
 end # module
 
-# End of file
+# End of file

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

@@ -10,4 +10,4 @@ require_relative './regex/alternation'
 require_relative './regex/non_capturing_group'
 require_relative './regex/anchor'
 require_relative './regex/lookaround'
-require_relative './regex/capturing_group'
+require_relative './regex/capturing_group'

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

@@ -105,7 +105,7 @@ module SRL
         # 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
+        token = build_token('INTEGER', lexeme) # An integer has 2..* digits
       elsif (lexeme = scanner.scan(/[0-9]/))
         token = build_token('DIGIT_LIT', lexeme)
       elsif (lexeme = scanner.scan(/[a-zA-Z]{2,}/))
@@ -132,7 +132,7 @@ module SRL
     def build_token(aSymbolName, aLexeme)
       begin
         token = Rley::Lexical::Token.new(aLexeme, aSymbolName)
-      rescue Exception => ex
+      rescue StandardError
         puts "Failing with '#{aSymbolName}' and '#{aLexeme}'"
         raise ex
       end

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

@@ -12,7 +12,7 @@ describe 'Integration tests:' do
   def regexp_repr(aResult)
     # Generate an abstract syntax parse tree from the parse result
     tree = @engine.convert(aResult)
-    regexp = tree.root
+    tree.root
   end
   
   before(:each) do
@@ -196,7 +196,7 @@ describe 'Integration tests:' do
   end # context
 
   context 'Parsing concatenation:' do
-    it "should reject dangling comma" do
+    it 'should reject dangling comma' do
       source = 'literally "a",'
       result = parse(source)
       expect(result).not_to be_success
@@ -212,7 +212,7 @@ describe 'Integration tests:' do
       expect(regexp.to_str).to eq('(?:sample|(?:\d+))')
     end
 
-    it "should parse a long sequence of patterns" do
+    it 'should parse a long sequence of patterns' do
       source = <<-ENDS
       any of (any character, one of "._%-+") once or more,
       literally "@",
@@ -225,8 +225,9 @@ ENDS
       expect(result).to be_success
 
       regexp = regexp_repr(result)
-      # SRL expect: (?:\w|[\._%\-\+])+(?:@)(?:[0-9]|[a-z]|[\.\-])+(?:\.)[a-z]{2,}
-      expect(regexp.to_str).to eq('(?:\w|[._%\-+])+@(?:\d|[a-z]|[.\-])+\.[a-z]{2,}')
+      # SRL: (?:\w|[\._%\-\+])+(?:@)(?:[0-9]|[a-z]|[\.\-])+(?:\.)[a-z]{2,}
+      expectation = '(?:\w|[._%\-+])+@(?:\d|[a-z]|[.\-])+\.[a-z]{2,}'
+      expect(regexp.to_str).to eq(expectation)
     end
   end # context
 
@@ -345,7 +346,8 @@ ENDS
     end  
   
     it 'should parse complex anonymous capturing group' do
-      result = parse('capture(any of (literally "sample", (digit once or more)))')
+      source = 'capture(any of (literally "sample", (digit once or more)))'
+      result = parse(source)
       expect(result).to be_success
 
       regexp = regexp_repr(result)
@@ -361,7 +363,11 @@ ENDS
     end
 
     it 'should parse complex named capturing group' do
-      result = parse('capture(any of (literally "sample", (digit once or more))) as "foo"')
+      source = <<-END_SRL
+capture(any of (literally "sample", (digit once or more)))
+  as "foo"      
+END_SRL
+      result = parse(source)
       expect(result).to be_success
 
       regexp = regexp_repr(result)
@@ -382,7 +388,8 @@ ENDS
     end   
 
     it 'should parse complex named until capturing group' do
-      result = parse('capture (anything once or more) as "foo" until literally "m"')
+      source = 'capture (anything once or more) as "foo" until literally "m"'
+      result = parse(source)
       expect(result).to be_success
 
       regexp = regexp_repr(result)
@@ -423,7 +430,7 @@ ENDS
       expect(regexp.to_str).to eq('^match$')
     end
 
-    it "should accept anchor with a sequence of patterns" do
+    it 'should accept anchor with a sequence of patterns' do
       source = <<-ENDS
       begin with any of (digit, letter, one of ".-") once or more,
       literally ".",
@@ -434,10 +441,8 @@ ENDS
       expect(result).to be_success
 
       regexp = regexp_repr(result)
-      # SRL expect: (?:\w|[\._%\-\+])+(?:@)(?:[0-9]|[a-z]|[\.\-])+(?:\.)[a-z]{2,}
+      # SRL: (?:\w|[\._%\-\+])+(?:@)(?:[0-9]|[a-z]|[\.\-])+(?:\.)[a-z]{2,}
       expect(regexp.to_str).to eq('^(?:\d|[a-z]|[.\-])+\.[a-z]{2,}$')
     end
   end # context
 end # describe
-
-

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

@@ -1,159 +1,166 @@
 # File: character_spec.rb
-require_relative '../spec_helper'	# Use the RSpec test framework
+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
+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].freeze
 
+    # This constant holds the codepoints of the character selection
+    SampleInts = [0x61, 0, 0x0107].freeze
+
+    # This constant holds an arbitrary selection of two characters (digrams) 
+    # escape sequences
+    SampleDigrams = %w[\n \e \0 \6 \k].freeze
+
+    # This constant holds an arbitrary selection of escaped octal 
+    # or hexadecimal literals
+    SampleNumEscs = %w[\0 \07 \x07 \xa \x0F \u03a3 \u{a}].freeze
+
+    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 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 do |aCodepoint|
+          Character.new(aCodepoint).char
+        end
+        expect(mapped_chars).to eq(SampleChars)
+
+        # Try with our escape sequence samples
+        (SampleDigrams + SampleNumEscs).each do |anEscSeq|
+          expectation = String.class_eval(%Q|"#{anEscSeq}"|, __FILE__, __LINE__)
+          Character.new(anEscSeq).to_str == expectation
+        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 do |aChar|
+          Character.new(aChar).codepoint
+        end
+        expect(allCodepoints).to eq(SampleInts)
+
+        # Try with our codepoint sample
+        mapped_chars = SampleInts.each do |aCodepoint|
+          expect(Character.new(aCodepoint).codepoint).to eq(aCodepoint)
+        end
+
+        # Try with our escape sequence samples
+        (SampleDigrams + SampleNumEscs).each do |anEscSeq|
+          expectation = String.class_eval(%Q|"#{anEscSeq}".ord()|, __FILE__, __LINE__)
+          expect(Character.new(anEscSeq).codepoint).to eq(expectation)
+        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
+# End of file