rley 0.6.01 → 0.6.02

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

@@ -1,57 +0,0 @@
-# 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
-    # 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/concatenation.rb

@@ -1,29 +0,0 @@
-# File: concatenation.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 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

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

@@ -1,60 +0,0 @@
-# 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
-    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

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

@@ -1,50 +0,0 @@
-# File: Lookaround.rb
-
-########################
-# TODO: make it a binary expression
-########################
-
-
-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.
-  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.
-    attr_reader(:dir)
-
-    # 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 ]
-    # [theKind] One of the following values: [ :positive, :negative ]
-    def initialize(assertedExpression, theDir, theKind)
-      super([assertedExpression])
-      @dir = theDir
-      @kind = theKind
-    end
-
-    # 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 + ')'
-      return result
-    end
-  end # class
-end # module
-
-# End of file

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

@@ -1,34 +0,0 @@
-# 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)
-
-    # An indicator that tells whether the option is turned on or off
-    attr_reader(:setting)
-
-    # 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

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

@@ -1,28 +0,0 @@
-# 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/multiplicity.rb

@@ -1,91 +0,0 @@
-# File: Multiplicity.rb
-
-module SRL
-  module Regex # This module is used as a namespace
-    # The multiplicity specifies by how much a given expression can be repeated.
-    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)
-      def initialize(aLowerBound, anUpperBound, aPolicy)
-        @lower_bound = valid_lower_bound(aLowerBound)
-        @upper_bound = valid_upper_bound(anUpperBound)
-        @policy = valid_policy(aPolicy)
-      end
-
-      # Purpose: Return the String representation of the multiplicity.
-      def to_str()
-        case upper_bound
-          when :more
-            case lower_bound
-              when 0
-                subresult = '*'
-              when 1
-                subresult = '+'
-              else
-                subresult = "{#{lower_bound},}"
-            end
-
-          when lower_bound
-            subresult = "{#{lower_bound}}"
-          else
-            if [lower_bound, upper_bound] == [0, 1]
-              subresult = '?'
-            else
-              subresult = "{#{lower_bound},#{upper_bound}}"
-            end
-        end
-
-        suffix = case policy
-          when :greedy
-            ''
-          when :lazy
-            '?'
-          when :possessive
-            '+'
-        end
-
-        return subresult + suffix
-      end
-
-      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)
-        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)
-          raise StandardError, err_msg
-        end
-
-        return anUpperBound
-      end
-
-      # Validation method. Return the validated policy value.
-      def valid_policy(aPolicy)
-        err_msg = "Invalid repetition policy '#{aPolicy}'."
-        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

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

@@ -1,27 +0,0 @@
-# File: non_capturing_group.rb
-
-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
-  class NonCapturingGroup < MonadicExpression
-    # Constructor.
-    # [aChildExpression]  A sub-expression to match. When successful
-    # the matching text is assigned to the capture variable.
-    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 + ')'
-      return result
-    end
-  end # class
-end # module
-
-# End of file

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

@@ -1,60 +0,0 @@
-# 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
-
-    # 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