rley 0.6.00 → 0.6.01

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

@@ -32,7 +32,7 @@ module SRL
     rule('pattern' => 'quantifiable').as 'basic_pattern'
     rule('separator' => 'COMMA').as 'comma_separator'
     rule('separator' => []).as 'void_separator'
-    rule('flags' => %[flags separator single_flag]).as 'flag_sequence'
+    rule('flags' => %w[flags separator single_flag]).as 'flag_sequence'
     rule('single_flag' => %w[CASE INSENSITIVE]).as 'case_insensitive'
     rule('single_flag' => %w[MULTI LINE]).as 'multi_line'
     rule('single_flag' => %w[ALL LAZY]).as 'all_lazy'
@@ -103,4 +103,4 @@ module SRL
 
   # And now build the grammar and make it accessible via a global constant
   Grammar = builder.grammar
-end # module
+end # module

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

@@ -3,33 +3,33 @@
 # 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
+  # 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(1..1)
+
+    # Extract the calling method name
+    callerNameInQuotes = top_line.scan(/`.+?$/).first
+    callerName = callerNameInQuotes.gsub(/`|'/, '') # Remove enclosing quotes
+
+    # Build the error message
+    prefix = "The method #{className}##{callerName} is abstract."
+    suffix = " It should be implemented in subclasses of #{className}."
+    error_message = prefix + suffix
+    raise NotImplementedError, error_message
+  end
 end # module
 
-# End of file
+# End of file

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

@@ -1,31 +1,27 @@
 # File: alternation.rb
 
-require_relative 'polyadic_expression'	# Access the superclass
+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
-class Alternation < PolyadicExpression
-	
-	# Constructor.
-	def initialize(*theChildren)
-		super(theChildren)
-	end
-
-  protected
-
-	# Conversion method re-definition.
-	# Purpose: Return the String representation of the concatented expressions.
-	def text_repr()
-		result_children = children.map { |aChild| aChild.to_str() }
-		result =  '(?:' + result_children.join('|') + ')'
-		
-		return result
-	end
-
-end # class
-
+  # Abstract class. A n-ary matching operator.
+  # It succeeds when one child expression succeeds to match the subject text
+  class Alternation < PolyadicExpression
+    # Constructor.
+    def initialize(*theChildren)
+      super(theChildren)
+    end
+
+    protected
+
+    # Conversion method re-definition.
+    # Purpose: Return the String representation of the concatented expressions.
+    def text_repr()
+      result_children = children.map(&:to_str)
+      result = '(?:' + result_children.join('|') + ')'
+
+      return result
+    end
+  end # class
 end # module
 
-# End of file
+# End of file

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

@@ -1,6 +1,6 @@
 # File: anchor.rb
 
-require_relative "atomic_expression"	# Access the superclass
+require_relative 'atomic_expression' # Access the superclass
 
 module Regex # This module is used as a namespace
   # An anchor is a zero-width assertion based on the current position.
@@ -8,15 +8,15 @@ module Regex # This module is used as a namespace
     # A Hash for converting a lexeme to a symbolic value
     AnchorToSymbol = {
       # Lexeme => Symbol value
-      '^' => :soLine,	# Start of line
-      '$' => :eoLine,	# End of line
+      '^' => :soLine, # Start of line
+      '$' => :eoLine, # End of line
       '\A' => :soSubject,
       '\b' => :wordBoundary,
       '\B' => :nonAtWordBoundary,
       '\G' => :firstMatch,
       '\z' => :eoSubject,
       '\Z' => :eoSubjectOrBeforeNLAtEnd
-    }
+    }.freeze
 
     # A symbolic value that identifies the type of assertion to perform
     attr_reader(:kind)
@@ -27,12 +27,10 @@ module Regex # This module is used as a namespace
       @kind = valid_kind(aKind)
     end
 
-    public
-
     # Conversion method re-definition.
     # Purpose: Return the String representation of the expression.
     def to_str()
-      return AnchorToSymbol.rassoc(kind).first()
+      return AnchorToSymbol.rassoc(kind).first
     end
 
     private
@@ -41,8 +39,7 @@ module Regex # This module is used as a namespace
     def valid_kind(aKind)
       return AnchorToSymbol[aKind]
     end
-
   end # class
 end # module
 
-# End of file
+# End of file

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

@@ -1,21 +1,16 @@
 # File: atomic_expression.rb
 
-require_relative "expression"	# Access the superclass
+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
-	
+  # Abstract class. A valid regular expression that
+  # cannot be further decomposed into sub-expressions.
+  class AtomicExpression < Expression
+    # Redefined method. Return true since it may not have any child.
+    def atomic?
+      return true
+    end
+  end # class
 end # module
 
-# End of file
+# End of file

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

@@ -1,30 +1,32 @@
 # File: 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
-
   # An association between a capture variable and an expression
   # the subject text in the same serial arrangement
   class CapturingGroup < MonadicExpression
-    # The capture variable id. It is a Fixnum when the capture group gets a sequence number, 
+    # The capture variable id. It is a Fixnum when the capture group gets 
+    # a sequence number,
     # a String when it is an user-defined name
     attr_reader(:id)
-    
-    # When true, then capturing group forbids backtracking requests from its parent expression. 
+
+    # When true, then capturing group forbids backtracking requests from its parent
+    # expression.
     attr_reader(:no_backtrack)
-    
+
     # Constructor.
-    # [aChildExpression]	A sub-expression to match. When successful the matching text is assigned to the capture variable.
+    # [aChildExpression]  A sub-expression to match. When successful 
+    #   the matching text is assigned to the capture variable.
     # [theId] The id of the capture variable.
-    # [noBacktrack] A flag that specifies whether the capturing group forbids backtracking requests from its parent expression.
+    # [noBacktrack] A flag that specifies whether the capturing group forbids 
+    #   backtracking requests from its parent expression.
     def initialize(aChildExpression, theId = nil, noBacktrack = false)
       super(aChildExpression)
       @id = theId
       @no_backtrack = noBacktrack
     end
-    
-  public
+
     # Return true iff the capturing group has a name (and not )
     def named?()
       return id.kind_of?(String)
@@ -37,14 +39,13 @@ module Regex # This module is used as a namespace
       atomic = no_backtrack ? '?>' : ''
       if child.is_a?(Regex::NonCapturingGroup)
         # Minor optimization
-        result = '(' + atomic + prefix + child.child.to_str + ")"
+        result = '(' + atomic + prefix + child.child.to_str + ')'
       else
-        result = '(' + atomic + prefix + child.to_str + ")"
+        result = '(' + atomic + prefix + child.to_str + ')'
       end
       return result
     end
-
   end # class
 end # module
 
-# End of file
+# End of file

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

@@ -1,41 +1,38 @@
 # File: char_class.rb
 
-require_relative "polyadic_expression"	# Access the superclass
+require_relative 'polyadic_expression' # Access the superclass
 
 module Regex # This module is used as a namespace
-
-  # Abstract class. A n-ary matching operator. 
+  # Abstract class. A n-ary matching operator.
   # It succeeds when one child expression succeeds to match the subject text.
   class CharClass < PolyadicExpression
     # These are characters with special meaning in character classes
     Metachars = ']\^-'.codepoints
     # A flag that indicates whether the character is negated
     attr_reader(:negated)
-    
+
     # Constructor.
-    def initialize(to_negate,*theChildren)
+    def initialize(to_negate, *theChildren)
       super(theChildren)
       @negated = to_negate
     end
 
     protected
-  
+
     # Conversion method re-definition.
     # Purpose: Return the String representation of the character class.
     def text_repr()
-      result_children = children.inject('') do |subResult, aChild| 
+      result_children = children.inject('') do |subResult, aChild|
         if aChild.kind_of?(Regex::Character) && Metachars.include?(aChild.codepoint)
           subResult << "\\" # Escape meta-character...
         end
-        subResult << aChild.to_str() 
+        subResult << aChild.to_str
       end
-      result = '['+ (negated ? '^' : '')  + result_children + ']'
-      
+      result = '[' + (negated ? '^' : '') + result_children + ']'
+
       return result
     end
-
   end # class
-
 end # module
 
-# End of file
+# End of file

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

@@ -1,52 +1,51 @@
 # File: char_range.rb
 
-require_relative 'polyadic_expression'	# Access the superclass
+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
-
-  protected
-
-	# Conversion method re-definition.
-	# Purpose: Return the String representation of the concatented expressions.
-	def text_repr()
-		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
-
+  # 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
+
+    # 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
+
+    protected
+
+    # Conversion method re-definition.
+    # Purpose: Return the String representation of the concatented expressions.
+    def text_repr()
+      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)
+      msg = 'Character range error: lower bound is greater than upper bound.'
+      raise StandardError, msg if theLowerBound.codepoint > theUpperBound.codepoint
+      return [theLowerBound, theUpperBound]
+    end
+  end # class
 end # module
 
-# End of file
+# End of file

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

@@ -1,9 +1,8 @@
 # File: char_shorthand.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 pre-defined character class is in essence a name for a built-in, standard character class.
   class CharShorthand < AtomicExpression
     # A constant Hash that defines all the predefined character shorthands.
@@ -18,7 +17,7 @@ module Regex # This module is used as a namespace
       'S' => '[^ \t\r\n\f]',
       'w' => '[0-9a-zA-Z_]',
       'W' => '[^0-9a-zA-Z_]'
-    }
+    }.freeze
 
     # An one-letter abbreviation
     attr_reader(:shortname)
@@ -29,23 +28,23 @@ module Regex # This module is used as a namespace
     end
 
     protected
-  
+
     # Conversion method re-definition.
     # Purpose: Return the String representation of the expression.
     def text_repr()
       return "\\#{shortname}"
     end
 
-  private
+    private
+
     # Return the validated short name.
     def valid_shortname(aShortname)
-      raise StandardError, "Unknown predefined character class \\#{aShortname}" unless StandardCClasses.include? aShortname
+      msg = "Unknown predefined character class \\#{aShortname}"
+      raise StandardError, msg unless StandardCClasses.include? aShortname
 
       return aShortname
     end
-
   end # class
-
 end # module
 
-# End of file
+# End of file