rley 0.6.00 → 0.6.01

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

@@ -1,33 +1,29 @@
 # File: concatenation.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 each child succeeds to match the subject text in the same
-# serial arrangement than defined by this concatenation.
-class Concatenation < 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.inject('') { |result, aChild|
-			result << aChild.to_str()
-		}
-
-		return result
-	end
-
-end # class
-
+  # Abstract class. A n-ary matching operator.
+  # It succeeds when each child succeeds to match the subject text in the same
+  # serial arrangement than defined by this concatenation.
+  class Concatenation < 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()
+      outcome = children.inject('') do |result, aChild|
+        result << aChild.to_str
+      end
+
+      return outcome
+    end
+  end # class
 end # module
 
-# End of file
+# End of file

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

@@ -3,61 +3,58 @@
 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
-  attr_accessor :begin_anchor
-  attr_accessor :end_anchor
-
-  # Constructor
-	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
-
-	# 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.
-	# @param theParentOptions [Hash] 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
-	
-	# Template method. 
-	# Purpose: Return the String representation of the expression.
-	def to_str()
-    result = ''
-    result << prefix
-    result << text_repr
-    result << suffix
-    
-    return result
-	end
-  
-  protected
-  
-  def prefix()
-    begin_anchor ? begin_anchor.to_str : ''
-  end
-  
-  def suffix()
-    end_anchor ? end_anchor.to_str : ''
-  end  
-  
-  
-
-end # class
-
+  # Abstract class. The generalization of any valid regular (sub)expression.
+  class Expression
+    attr_accessor :begin_anchor
+    attr_accessor :end_anchor
+
+    # Constructor
+    def initialize(); end
+
+    # 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.
+    # [_parent_options] an Hash of matching options. They are overridden 
+    #   by options with same name that are bound to this object.
+    def cardinality(_parent_options) 
+      abstract_method
+    end
+
+    # 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.
+    # @param theParentOptions [Hash] 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
+
+    # Template method.
+    # Purpose: Return the String representation of the expression.
+    def to_str()
+      result = ''
+      result << prefix
+      result << text_repr
+      result << suffix
+
+      return result
+    end
+
+    protected
+
+    def prefix()
+      begin_anchor ? begin_anchor.to_str : ''
+    end
+
+    def suffix()
+      end_anchor ? end_anchor.to_str : ''
+    end
+  end # class
 end # module
 
-# End of file
+# End of file

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

@@ -1,47 +1,50 @@
 # File: Lookaround.rb
 
 ########################
-# TODO: make it a binary expression 
+# TODO: make it a binary expression
 ########################
 
 
-require_relative 'polyadic_expression'	# Access the superclass
+require_relative 'polyadic_expression' # Access the superclass
 
 module Regex # This module is used as a namespace
-  # Lookaround is a zero-width assertion just like the start and end of line anchors.
-  # The difference is that lookarounds will actually match characters, but only return the result of the match: match or no match.
-  # That is why they are called "assertions". They do not consume characters from the subject,
-  # but only assert whether a match is possible or not. 
+  # Lookaround is a zero-width assertion just like the start and end of line
+  # anchors.
+  # The difference is that lookarounds will actually match characters, but only
+  # return the result of the match: match or no match.
+  # That is why they are called "assertions". They do not consume characters
+  # from the subject, but only assert whether a match is possible or not.
   class Lookaround < PolyadicExpression
-    # The "direction" of the lookaround. Can be ahead or behind. It specifies the relative position of the 
-    # expression to match compared to the current 'position' in the subject text.
+    # The "direction" of the lookaround. Can be ahead or behind. It specifies
+    # the relative position of the expression to match compared to
+    # the current 'position' in the subject text.
     attr_reader(:dir)
-    
-    # The kind indicates whether the assertion is positive (succeeds when there is a match) or negative
+
+    # The kind indicates whether the assertion is positive
+    # (succeeds when there is a match) or negative
     # (assertion succeeds when there is NO match).
     attr_reader(:kind)
-    
+
     # Constructor.
-    # [assertedExpression]	A sub-expression to match.
-    # [theDir]	One of the following values: [ :ahead, :behind ]
+    # [assertedExpression]  A sub-expression to match.
+    # [theDir]  One of the following values: [ :ahead, :behind ]
     # [theKind] One of the following values: [ :positive, :negative ]
     def initialize(assertedExpression, theDir, theKind)
       super([assertedExpression])
-      @dir, @kind = theDir, theKind
+      @dir = theDir
+      @kind = theKind
     end
-    
-  public
+
     # Conversion method re-definition.
     # Purpose: Return the String representation of the captured expression.
     def to_str()
       result = children[0].to_str
       dir_syntax = (dir == :ahead) ? '' : '<'
-      kind_syntax = (kind == :positive)? '=' : '!'
-      result << '(?' + dir_syntax + kind_syntax + children[1].to_str + ")"
+      kind_syntax = (kind == :positive) ? '=' : '!'
+      result << '(?' + dir_syntax + kind_syntax + children[1].to_str + ')'
       return result
     end
-
   end # class
 end # module
 
-# End of file
+# End of file

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

@@ -1,36 +1,34 @@
 # File: MatchOption.rb
 
 module Regex # This module is used as a namespace
+  # Represents an option that influences the way a regular (sub)expression 
+  # can perform its matching.
+  class MatchOption
+    # The symbolic name of the option
+    attr_reader(:name)
 
-# Represents an option that influences the way a regular (sub)expression can perform its matching.
-class MatchOption
-	# The symbolic name of the option
-	attr_reader(:name)
-	
-	# An indicator that tells whether the option is turned on or off
-	attr_reader(:setting)
-	
-	# Constructor.
-	def initialize(theName, theSetting)
-		@name, @setting = theName, theSetting
-	end
-	
-public
-	# Equality operator
-	def ==(another)
-		return true if self.object_id == another.object_id
-		
-		if another.kind_of?(MatchOption)
-			isEqual = ((name == another.name) && (setting == another.setting))
-		else
-			isEqual = false
-		end
-		
-		return isEqual
-	end
+    # An indicator that tells whether the option is turned on or off
+    attr_reader(:setting)
 
-end # class
+    # Constructor.
+    def initialize(theName, theSetting)
+      @name = theName
+      @setting = theSetting
+    end
+  
+    # Equality operator
+    def ==(other)
+      return true if object_id == other.object_id
 
+      if other.kind_of?(MatchOption)
+        isEqual = ((name == other.name) && (setting == other.setting))
+      else
+        isEqual = false
+      end
+
+      return isEqual
+    end
+  end # class
 end # module
 
-# End of file
+# End of file

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

@@ -1,31 +1,28 @@
 # File: monadic_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 can have up to one child sub-expression.
+  class MonadicExpression < CompoundExpression
+    # The (optional) child sub-expression
+    attr_reader(:child)
 
-# 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
+    # Constructor.
+    def initialize(theChild)
+      super()
+      @child = theChild
+    end
 
-end # class
+    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
+# End of file

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

@@ -6,13 +6,13 @@ module SRL
     class Multiplicity
       # The lowest acceptable repetition count
       attr_reader(:lower_bound)
-      
+
       # The highest possible repetition count
       attr_reader(:upper_bound)
 
       # An indicator that specifies how to repeat (:greedy, :lazy, :possessive)
       attr_reader(:policy)
-      
+
       # @param aLowerBound [Integer]
       # @param anUpperBound [Integer, Symbol] integer or :more symbol
       # @param aPolicy [Symbol] One of: (:greedy, :lazy, :possessive)
@@ -21,8 +21,7 @@ module SRL
         @upper_bound = valid_upper_bound(anUpperBound)
         @policy = valid_policy(aPolicy)
       end
-      
-    public
+
       # Purpose: Return the String representation of the multiplicity.
       def to_str()
         case upper_bound
@@ -35,7 +34,7 @@ module SRL
               else
                 subresult = "{#{lower_bound},}"
             end
-            
+
           when lower_bound
             subresult = "{#{lower_bound}}"
           else
@@ -45,7 +44,7 @@ module SRL
               subresult = "{#{lower_bound},#{upper_bound}}"
             end
         end
-        
+
         suffix = case policy
           when :greedy
             ''
@@ -54,41 +53,39 @@ module SRL
           when :possessive
             '+'
         end
-        
+
         return subresult + suffix
       end
-      
-      
-    private
+
+      private
+
       # Validation method. Return the validated lower bound value
       def valid_lower_bound(aLowerBound)
         err_msg = "Invalid lower bound of repetition count #{aLowerBound}"
-        raise StandardError, err_msg unless aLowerBound.kind_of?(Integer) 
+        raise StandardError, err_msg unless aLowerBound.kind_of?(Integer)
         return aLowerBound
       end
-      
+
       # Validation method. Return the validated lower bound value
       def valid_upper_bound(anUpperBound)
         err_msg = "Invalid upper bound of repetition count #{anUpperBound}"
-        unless anUpperBound.kind_of?(Integer) || (anUpperBound == :more)	
+        unless anUpperBound.kind_of?(Integer) || (anUpperBound == :more)
           raise StandardError, err_msg
         end
-        
+
         return anUpperBound
-      end	
-      
+      end
+
       # Validation method. Return the validated policy value.
       def valid_policy(aPolicy)
         err_msg = "Invalid repetition policy '#{aPolicy}'."
-        valid_policies = [:greedy, :lazy, :possessive]
+        valid_policies = %i[greedy lazy possessive]
         raise StandardError, err_msg unless valid_policies.include? aPolicy
 
         return aPolicy
       end
-
     end # class
-
   end # module
 end # module
 
-# End of file
+# End of file