rley 0.6.01 → 0.6.02

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

@@ -1,166 +0,0 @@
-# File: character_spec.rb
-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].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

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

@@ -1,79 +0,0 @@
-# File: Multiplicity_spec.rb
-
-require_relative '../spec_helper' # Use the RSpec test framework
-require_relative '../../lib/regex/multiplicity'
-
-module SRL
-  # Reopen the module, in order to get rid of fully qualified names
-  module Regex # This module is used as a namespace
-    describe Multiplicity do
-      context 'Creation & initialisation' do
-        it 'should be created with 3 arguments' do
-          # Valid cases: initialized with two integer values and a policy symbol
-          %i[greedy lazy possessive].each do |aPolicy|
-            expect { Multiplicity.new(0, 1, aPolicy) }.not_to raise_error
-          end
-
-          # Invalid case: initialized with invalid policy value
-          err = StandardError
-          msg = "Invalid repetition policy 'KO'."
-          expect { Multiplicity.new(0, :more, 'KO') }.to raise_error(err, msg)
-        end
-      end
-
-      context 'Provided services' do
-        it 'should know its text representation' do
-          policy2text = { greedy: '', lazy: '?', possessive: '+' }
-
-          # Case: zero or one
-          policy2text.each_key do |aPolicy|
-            multi = Multiplicity.new(0, 1, aPolicy)
-            expect(multi.to_str).to eq("?#{policy2text[aPolicy]}")
-          end
-
-          # Case: zero or more
-          policy2text.each_key do |aPolicy|
-            multi = Multiplicity.new(0, :more, aPolicy)
-            expect(multi.to_str).to eq("*#{policy2text[aPolicy]}")
-          end
-
-          # Case: one or more
-          policy2text.each_key do |aPolicy|
-            multi = Multiplicity.new(1, :more, aPolicy)
-            expect(multi.to_str).to eq("+#{policy2text[aPolicy]}")
-          end
-
-          # Case: exactly m times
-          policy2text.each_key do |aPolicy|
-            samples = [1, 2, 5, 100]
-            samples.each do |aCount|
-              multi = Multiplicity.new(aCount, aCount, aPolicy)
-              expect(multi.to_str).to eq("{#{aCount}}#{policy2text[aPolicy]}")
-            end
-          end
-
-          # Case: m, n times
-          policy2text.each_key do |aPolicy|
-            samples = [1, 2, 5, 100]
-            samples.each do |aCount|
-              upper = aCount + 1 + rand(20)
-              multi = Multiplicity.new(aCount, upper, aPolicy)
-              expectation = "{#{aCount},#{upper}}#{policy2text[aPolicy]}"
-              expect(multi.to_str).to eq(expectation)
-            end
-          end
-
-          # Case: m or more
-          policy2text.each_key do |aPolicy|
-            samples = [2, 3, 5, 100]
-            samples.each do |aCount|
-              multi = Multiplicity.new(aCount, :more, aPolicy)
-              expect(multi.to_str).to eq("{#{aCount},}#{policy2text[aPolicy]}")
-            end
-          end
-        end
-      end
-    end
-  end # module
-end # module
-# End of file

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

@@ -1,25 +0,0 @@
-# File: spec_helper.rb
-# Purpose: utility file that is loaded by all our RSpec files
-
-require 'simplecov'
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
-  [
-    SimpleCov::Formatter::HTMLFormatter
-  ]
-)
-
-require 'pp'    # Use pretty-print for debugging purposes
-require 'rspec' # Use the RSpec framework
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |c|
-    # Disable the `should` syntax...
-    c.syntax = :expect
-  end
-
-  # Display stack trace in case of failure
-  config.full_backtrace = true
-end
-
-# End of file

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

@@ -1,148 +0,0 @@
-require_relative 'spec_helper' # Use the RSpec framework
-require_relative '../lib/tokenizer' # Load the class under test
-
-
-module SRL
-  describe Tokenizer do
-    def match_expectations(aTokenizer, theExpectations)
-      aTokenizer.tokens.each_with_index do |token, i|
-        terminal, lexeme = theExpectations[i]
-        expect(token.terminal).to eq(terminal)
-        expect(token.lexeme).to eq(lexeme)
-      end
-    end
-  
-    subject { Tokenizer.new('') }    
-    
-    context 'Initialization:' do
-      it 'should be initialized with a text to tokenize and a grammar' do
-        expect { Tokenizer.new('anything') }.not_to raise_error
-      end
-
-      it 'should have its scanner initialized' do
-        expect(subject.scanner).to be_kind_of(StringScanner)
-      end
-    end # context
-
-    context 'Single token recognition:' do
-      it 'should tokenize delimiters and separators' do
-        subject.scanner.string = ','
-        token = subject.tokens.first
-        expect(token).to be_kind_of(Rley::Lexical::Token)
-        expect(token.terminal).to eq('COMMA')
-        expect(token.lexeme).to eq(',')
-      end
-      
-      it 'should tokenize keywords' do
-        sample = 'between Exactly oncE optional TWICE'
-        subject.scanner.string = sample
-        subject.tokens.each do |tok|
-          expect(tok).to be_kind_of(Rley::Lexical::Token)
-          expect(tok.terminal).to eq(tok.lexeme.upcase)
-        end
-      end
-      
-      it 'should tokenize integer values' do
-        subject.scanner.string = ' 123 '
-        token = subject.tokens.first
-        expect(token).to be_kind_of(Rley::Lexical::Token)
-        expect(token.terminal).to eq('INTEGER')
-        expect(token.lexeme).to eq('123')
-      end 
-
-      it 'should tokenize single digits' do
-        subject.scanner.string = ' 1 '
-        token = subject.tokens.first
-        expect(token).to be_kind_of(Rley::Lexical::Token)
-        expect(token.terminal).to eq('DIGIT_LIT')
-        expect(token.lexeme).to eq('1')
-      end       
-    end # context
-    
-    context 'String literal tokenization:' do
-      it "should recognize 'literally ...'" do
-        input = 'literally "hello"'
-        subject.scanner.string = input
-        expectations = [
-          %w[LITERALLY literally],
-          %w[STRING_LIT hello]
-        ]
-        match_expectations(subject, expectations)
-      end    
-    end # context    
-    
-    context 'Character range tokenization:' do
-      it "should recognize 'letter from ... to ...'" do
-        input = 'letter a to f'
-        subject.scanner.string = input
-        expectations = [
-          %w[LETTER letter],
-          %w[LETTER_LIT a],
-          %w[TO to],
-          %w[LETTER_LIT f]
-        ]
-        match_expectations(subject, expectations)
-      end    
-    end # context
-    
-    context 'Quantifier tokenization:' do
-      it "should recognize 'exactly ... times'" do
-        input = 'exactly 4 Times'
-        subject.scanner.string = input
-        expectations = [
-          %w[EXACTLY exactly],
-          %w[DIGIT_LIT 4],
-          %w[TIMES Times]
-        ]
-        match_expectations(subject, expectations)
-      end
-      
-      it "should recognize 'between ... and ... times'" do
-        input = 'Between 2 AND 4 times'
-        subject.scanner.string = input
-        expectations = [
-          %w[BETWEEN Between],
-          %w[DIGIT_LIT 2],
-          %w[AND AND],
-          %w[DIGIT_LIT 4],
-          %w[TIMES times]
-        ]
-        match_expectations(subject, expectations)
-      end
-
-      it "should recognize 'once or more'" do
-        input = 'Once or MORE'
-        subject.scanner.string = input
-        expectations = [
-          %w[ONCE Once],
-          %w[OR or],
-          %w[MORE MORE]
-        ]
-        match_expectations(subject, expectations)
-      end
-
-      it "should recognize 'never or more'" do
-        input = 'never or more'
-        subject.scanner.string = input
-        expectations = [
-          %w[NEVER never],
-          %w[OR or],
-          %w[MORE more]
-        ]
-        match_expectations(subject, expectations)
-      end 
-
-      it "should recognize 'at least  ... times'" do
-        input = 'at least 10 times'
-        subject.scanner.string = input
-        expectations = [
-          %w[AT at],
-          %w[LEAST least],
-          %w[INTEGER 10],
-          %w[TIMES times]
-        ]
-        match_expectations(subject, expectations)
-      end      
-    end # context
-  end # describe
-end # module

data/examples/general/SRL/srl_demo.rb

@@ -1,75 +0,0 @@
-require_relative './lib/tokenizer'
-require_relative './lib/grammar'
-require_relative './lib/ast_builder'
-
-def print_title(aTitle)
-  puts aTitle
-  puts '=' * aTitle.size
-end
-
-def print_tree(aTitle, aParseTree)
-  # Let's create a parse tree visitor
-  visitor = Rley::ParseTreeVisitor.new(aParseTree)
-
-  # Now output formatted parse tree
-  print_title(aTitle)
-  renderer = Rley::Formatter::Asciitree.new($stdout)
-  renderer.render(visitor)
-  puts ''
-end
-
-# Parse the input expression in command-line
-if ARGV.empty?
-  my_name = File.basename(__FILE__)
-  msg = <<-END_MSG
-WORK IN PROGRESS
-Simple Regex Language parser:
-- Parses a very limited subset of the 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 ARGV[0]
-
-# Create a Rley facade object
-engine = Rley::Engine.new
-
-########################################
-# Step 1. Load a grammar for calculator
-engine.use_grammar(SRL::Grammar)
-
-lexer = SRL::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 a concrete syntax parse tree from the parse result
-cst_ptree = engine.convert(result)
-print_tree('Concrete Syntax Tree (CST)', cst_ptree)
-
-# Generate an abstract syntax tree (AST) from the parse result
-engine.configuration.repr_builder = ASTBuilder
-ast_ptree = engine.convert(result)
-
-# Now output the regexp literal
-root = ast_ptree.root
-print_title('SRL to Regexp representation:')
-puts "#{ARGV[0]} => #{root.to_str}" # Output the expression result
-
-# End of file