srl_ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a80b384a696db072da2e0b05df48bbb318ca817d
+  data.tar.gz: 85269501fe730ed717ed673dbb949f47025462a0
+SHA512:
+  metadata.gz: 8041e060c085687c4ca8a11bfc6d893be0495c8620aeba085a83e1d2b294ddecf0844c2c98399b08b9f861b038ed4eea28018f4936b87f2384330ee9dbaaf169
+  data.tar.gz: a378f1a8bf10787555ff7ccb3906968b441821356cebccb0b32db0661ff23ca078b267e252b939110fe9125a618f16ed52eb7b98f3aebb5668e4a25587e11cf7

data/.rspec

@@ -0,0 +1,4 @@
+--backtrace
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,3 @@
+Layout/EndOfLine:
+  Enabled: true
+  EnforcedStyle: lf

data/.yardopts

@@ -0,0 +1,6 @@
+--exclude examples --exclude features --exclude spec
+--no-private
+--markup markdown
+-
+Changelog.md
+License.txt

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in srl_ruby.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 TODO: Write your name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,66 @@
+# SrlRuby
+[![Build Status](https://travis-ci.org/famished-tiger/SRL-Ruby.svg?branch=master)](https://travis-ci.org/famished-tiger/SRL-Ruby)
+
+This project implements a [Simple Regex Language](https://simple-regex.com) interpreter in Ruby.
+
+## What is SRL?
+SRL is a small language lets you write regular expressions
+with a readable syntax that bears some resemblance with English.
+Here are a couple of hyperlinks of interest:  
+[Main SRL website](https://simple-regex.com)  
+[SRL libraries](https://github.com/SimpleRegex)
+
+
+## An example
+Let's assume that we want to create a regular expression that recognizes time in a day in the 24 hours format hh:mm:ss.
+In SRL:
+```
+digit from 0 to 2, digit,
+(literally ':', digit from 0 to 5, digit) twice
+```
+
+If one runs the `srl_ruby` command-line like this:
+
+```
+srl_ruby "digit from 0 to 2, digit, (literally ':', digit from 0 to 5, digit) twice"
+```
+It replies with:
+```
+SRL input: digit from 0 to 2, digit, (literally ':', digit from 0 to 5, digit) twice
+Resulting Regexp: /[0-2]\d(?::[0-5]\d){2}/
+```
+
+In other words, it translates a readable SRL expression into its regexp equivalent.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'srl_ruby'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install srl_ruby
+
+## Usage
+
+TODO: Write usage instructions here
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/famished-tiger/SRL-Ruby. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the SrlRuby project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/srl_ruby/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,16 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc 'Run RSpec'
+RSpec::Core::RakeTask.new do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+end
+
+
+# Combine RSpec tests
+desc 'Run tests, with RSpec'
+task test: [:spec]
+
+
+# Default rake task
+task default: :test

data/bin/srl_ruby

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+require_relative '../lib/srl_ruby/tokenizer'
+require_relative '../lib/srl_ruby/grammar'
+require_relative '../lib/srl_ruby/ast_builder'
+
+def print_title(aTitle)
+  puts aTitle
+  puts '=' * aTitle.size
+end
+
+# Parse the input expression in command-line
+if ARGV.empty?
+  my_name = File.basename(__FILE__)
+  msg = <<-END_MSG
+Simple Regex Language parser:
+- Parses a subset of the SRL language and displays the parse tree
+
+Command-line syntax:
+  ruby #{my_name} "SRL expression"
+  where:
+    the SRL expression is enclosed between double quotes (")
+
+  Examples:
+  ruby #{my_name} "letter from a to f exactly 4 times"
+  ruby #{my_name} "uppercase letter between 2 and 3 times"
+  ruby #{my_name} "digit from 0 to 7 once or more"
+END_MSG
+  puts msg
+  exit(1)
+end
+puts 'SRL input: ' + ARGV[0]
+
+# Create a Rley facade object
+engine = Rley::Engine.new
+
+########################################
+# Step 1. Load a grammar for calculator
+engine.use_grammar(SrlRuby::Grammar)
+
+lexer = SrlRuby::Tokenizer.new(ARGV[0])
+result = engine.parse(lexer.tokens)
+
+unless result.success?
+  # Stop if the parse failed...
+  puts "Parsing of '#{ARGV[0]}' failed"
+  puts "Reason: #{result.failure_reason.message}"
+  exit(1)
+end
+
+# Generate an abstract syntax tree (AST) from the parse result
+engine.configuration.repr_builder = SrlRuby::ASTBuilder
+ast_ptree = engine.convert(result)
+
+# Now output the regexp literal
+root = ast_ptree.root
+puts "Resulting Regexp: /#{root.to_str}/" # Output the expression result
+
+# End of file

data/lib/regex/abstract_method.rb

@@ -0,0 +1,35 @@
+# File: abstract_method.rb
+
+# Mix-in module. Provides the method 'abstract_method' that raises an exception
+# with an appropriate message when called.
+module AbstractMethod
+  # 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

data/lib/regex/alternation.rb

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

data/lib/regex/anchor.rb

@@ -0,0 +1,45 @@
+# File: anchor.rb
+
+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.
+  class Anchor < AtomicExpression
+    # A Hash for converting a lexeme to a symbolic value
+    AnchorToSymbol = {
+      # Lexeme => Symbol value
+      '^' => :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)
+
+    # Constructor
+    # @param aKind [String] Lexeme representation of the anchor
+    def initialize(aKind)
+      @kind = valid_kind(aKind)
+    end
+
+    # Conversion method re-definition.
+    # Purpose: Return the String representation of the expression.
+    def to_str()
+      return AnchorToSymbol.rassoc(kind).first
+    end
+
+    private
+
+    # Return the symbolic value corresponding to the given lexeme.
+    def valid_kind(aKind)
+      return AnchorToSymbol[aKind]
+    end
+  end # class
+end # module
+
+# End of file

data/lib/regex/atomic_expression.rb

@@ -0,0 +1,16 @@
+# File: atomic_expression.rb
+
+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
+    # Redefined method. Return true since it may not have any child.
+    def atomic?
+      return true
+    end
+  end # class
+end # module
+
+# End of file

data/lib/regex/capturing_group.rb

@@ -0,0 +1,51 @@
+# File: capturing_group.rb
+
+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,
+    # a String when it is an user-defined name
+    attr_reader(:id)
+
+    # 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.
+    # [theId] The id of the capture variable.
+    # [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
+
+    # Return true iff the capturing group has a name (and not )
+    def named?()
+      return id.kind_of?(String)
+    end
+
+    # Conversion method re-definition.
+    # Purpose: Return the String representation of the captured expression.
+    def to_str()
+      prefix = named? ? "?<#{id}>" : ''
+      atomic = no_backtrack ? '?>' : ''
+      if child.is_a?(Regex::NonCapturingGroup)
+        # Minor optimization
+        result = '(' + atomic + prefix + child.child.to_str + ')'
+      else
+        result = '(' + atomic + prefix + child.to_str + ')'
+      end
+      return result
+    end
+  end # class
+end # module
+
+# End of file

data/lib/regex/char_class.rb

@@ -0,0 +1,38 @@
+# File: char_class.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 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)
+      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|
+        if aChild.kind_of?(Regex::Character) && Metachars.include?(aChild.codepoint)
+          subResult << "\\" # Escape meta-character...
+        end
+        subResult << aChild.to_str
+      end
+      result = '[' + (negated ? '^' : '') + result_children + ']'
+
+      return result
+    end
+  end # class
+end # module
+
+# End of file

data/lib/regex/char_range.rb

@@ -0,0 +1,51 @@
+# File: char_range.rb
+
+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
+
+    # 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

data/lib/regex/char_shorthand.rb

@@ -0,0 +1,50 @@
+# File: char_shorthand.rb
+
+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.
+    # It contains pairs of the form:
+    # a pre-defined character shorthand letter => a CharRange object
+    StandardCClasses = {
+      'd' => '[0-9]',
+      'D' => '[^0-9]',
+      'h' => '[0-9a-fA-F]',
+      'H' => '[^0-9a-fA-F]',
+      's' => '[ \t\r\n\f]',
+      'S' => '[^ \t\r\n\f]',
+      'w' => '[0-9a-zA-Z_]',
+      'W' => '[^0-9a-zA-Z_]'
+    }.freeze
+
+    # An one-letter abbreviation
+    attr_reader(:shortname)
+
+    # Constructor
+    def initialize(aShortname)
+      @shortname = valid_shortname(aShortname)
+    end
+
+    protected
+
+    # Conversion method re-definition.
+    # Purpose: Return the String representation of the expression.
+    def text_repr()
+      return "\\#{shortname}"
+    end
+
+    private
+
+    # Return the validated short name.
+    def valid_shortname(aShortname)
+      msg = "Unknown predefined character class \\#{aShortname}"
+      raise StandardError, msg unless StandardCClasses.include? aShortname
+
+      return aShortname
+    end
+  end # class
+end # module
+
+# End of file