dendroid 0.1.00 → 0.2.01

data/lib/dendroid/syntax/production.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'rule'
-
-module Dendroid
-  module Syntax
-    # A specialization of the Rule class.
-    # A production is a rule with a single rhs
-    class Production < Rule
-      # @return [Dendroid::Syntax::SymbolSeq]
-      attr_reader :body
-
-      # Create a Production instance.
-      # @param lhs [Dendroid::Syntax::NonTerminal] The left-hand side of the rule.
-      # @param rhs [Dendroid::Syntax::SymbolSeq] the sequence of symbols on rhs.
-      def initialize(lhs, rhs)
-        super(lhs)
-        @body = valid_sequence(rhs)
-      end
-
-      # Predicate method to check whether the rule body (its rhs) is empty.
-      # @return [Boolean]
-      def empty?
-        body.empty?
-      end
-
-      # Predicate method to check whether the rule has alternatives
-      # @return [FalseClass]
-      def choice?
-        false
-      end
-
-      # Predicate method to check whether the production rule body is productive.
-      # It is productive when it is empty or all of its rhs members are productive too.
-      # @return [Boolean, NilClass]
-      def productive?
-        if @productive.nil?
-          if body.productive?
-            self.productive = true
-          else
-            nil
-          end
-        else
-          @productive
-        end
-      end
-
-      # Mark the production rule as non-productive.
-      def non_productive
-        self.productive = false
-      end
-
-      # Return the text representation of the production rule
-      # @return [String]
-      def to_s
-        "#{head} => #{body}"
-      end
-
-      # Equality operator
-      # Two production rules are equal when their head and rhs are equal.
-      # @return [Boolean]
-      def ==(other)
-        return true if equal?(other)
-
-        (head == other.head) && (body == other.body)
-      end
-
-      # Returns an array with the symbol sequence of its rhs
-      # @return [Array<Dendroid::Syntax::SymbolSeq>]
-      def rhs
-        [body]
-      end
-
-      private
-
-      def productive=(val)
-        @productive = val
-        lhs.productive = val
-      end
-    end # class
-  end # module
-end # module

data/spec/dendroid/grm_analysis/alternative_item_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '..\..\spec_helper'
-require_relative '..\..\..\lib\dendroid\syntax\terminal'
-require_relative '..\..\..\lib\dendroid\syntax\non_terminal'
-require_relative '..\..\..\lib\dendroid\syntax\symbol_seq'
-require_relative '..\..\..\lib\dendroid\syntax\production'
-require_relative '..\..\..\lib\dendroid\grm_analysis\alternative_item'
-
-describe Dendroid::GrmAnalysis::DottedItem do
-  # TODO
-end # describe

data/spec/dendroid/grm_analysis/production_items_spec.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../spec_helper'
-require_relative '../../../lib/dendroid/syntax/terminal'
-require_relative '../../../lib/dendroid/syntax/non_terminal'
-require_relative '../../../lib/dendroid/syntax/symbol_seq'
-require_relative '../../../lib/dendroid/syntax/production'
-require_relative '../../../lib/dendroid/grm_analysis/production_items'
-
-describe Dendroid::GrmAnalysis::ProductionItems do
-  let(:num_symb) { Dendroid::Syntax::Terminal.new('NUMBER') }
-  let(:plus_symb) { Dendroid::Syntax::Terminal.new('PLUS') }
-  let(:expr_symb) { Dendroid::Syntax::NonTerminal.new('expression') }
-  let(:rhs) { Dendroid::Syntax::SymbolSeq.new([num_symb, plus_symb, num_symb]) }
-  let(:empty_body) { Dendroid::Syntax::SymbolSeq.new([]) }
-  let(:prod) { Dendroid::Syntax::Production.new(expr_symb, rhs) }
-  let(:empty_prod) do
-    e = Dendroid::Syntax::Production.new(expr_symb, empty_body)
-    e.extend(Dendroid::GrmAnalysis::ProductionItems)
-    e.build_items
-    e
-  end
-
-  subject do
-    prod.extend(Dendroid::GrmAnalysis::ProductionItems)
-    prod.build_items
-    prod
-  end
-
-  context 'Methods from mix-in' do
-    it 'builds items for given non-empty production' do
-      expect(subject.items.size).to eq(subject.body.size + 1)
-      subject.items.each_with_index do |item, index|
-        expect(item.rule).to eq(subject)
-        expect(item.position).to eq(index)
-      end
-    end
-
-    it 'builds the item for given empty production' do
-      expect(empty_prod.items.size).to eq(1)
-      expect(empty_prod.items[0].rule).to eq(empty_prod)
-      expect(empty_prod.items[0].position).to eq(0)
-    end
-
-    it 'returns the first (predicted) item of the production' do
-      expect(subject.predicted_items).to eq([subject.items.first])
-      expect(empty_prod.predicted_items).to eq([empty_prod.items.first])
-    end
-
-    it 'returns the last (reduce) item of the production' do
-      expect(subject.reduce_items).to eq([subject.items.last])
-      expect(empty_prod.reduce_items).to eq([empty_prod.items.first])
-    end
-
-    # rubocop: disable Style/EachForSimpleLoop
-    it 'returns the consecutive item to a given one' do
-      (0..2).each do |pos|
-        curr_item = subject.items[pos]
-        next_one = subject.next_item(curr_item)
-        expect(next_one).to eq(subject.items[pos + 1])
-      end
-      expect(subject.next_item(subject.items[-1])).to be_nil
-
-      expect(empty_prod.next_item(empty_prod.items[-1])).to be_nil
-    end
-    # rubocop: enable Style/EachForSimpleLoop
-  end # context
-end # describe

data/spec/dendroid/syntax/choice_spec.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '..\..\spec_helper'
-require_relative '..\..\..\lib\dendroid\syntax\terminal'
-require_relative '..\..\..\lib\dendroid\syntax\non_terminal'
-require_relative '..\..\..\lib\dendroid\syntax\symbol_seq'
-require_relative '..\..\..\lib\dendroid\syntax\choice'
-
-describe Dendroid::Syntax::Choice do
-  let(:num_symb) { Dendroid::Syntax::Terminal.new('NUMBER') }
-  let(:plus_symb) { Dendroid::Syntax::Terminal.new('PLUS') }
-  let(:minus_symb) { Dendroid::Syntax::Terminal.new('MINUS') }
-  let(:expr_symb) { Dendroid::Syntax::NonTerminal.new('expression') }
-  let(:foo_symb) { Dendroid::Syntax::NonTerminal.new('foo') }
-  let(:alt1) { Dendroid::Syntax::SymbolSeq.new([num_symb, plus_symb, num_symb]) }
-  let(:alt2) { Dendroid::Syntax::SymbolSeq.new([num_symb, minus_symb, num_symb]) }
-  let(:empty_body) { Dendroid::Syntax::SymbolSeq.new([]) }
-
-  # Implements a choice rule:
-  #   expression => NUMBER PLUS NUMBER
-  #              |  NUMBER MINUS NUMBER
-  #              |  epsilon
-  subject { described_class.new(expr_symb, [alt1, alt2, empty_body]) }
-
-  context 'Initialization:' do
-    it 'is initialized with a head and alternatives' do
-      expect { described_class.new(expr_symb, [alt1, alt2, empty_body]) }.not_to raise_error
-    end
-
-    it 'knows its alternatives' do
-      expect(subject.alternatives).to eq([alt1, alt2, empty_body])
-    end
-
-    it 'renders a String representation of itself' do
-      expectation = 'expression => NUMBER PLUS NUMBER | NUMBER MINUS NUMBER | '
-      expect(subject.to_s).to eq(expectation)
-    end
-  end # context
-
-  context 'Provided services:' do
-    it 'knows its terminal members' do
-      expect(subject.terminals).to eq([num_symb, plus_symb, minus_symb])
-    end
-
-    it 'knows its non-terminal members' do
-      expect(subject.nonterminals).to be_empty
-
-      my_alt1 = Dendroid::Syntax::SymbolSeq.new([expr_symb, plus_symb, expr_symb])
-      my_alt2 = Dendroid::Syntax::SymbolSeq.new([foo_symb, minus_symb, expr_symb])
-      instance = described_class.new(foo_symb, [my_alt1, my_alt2])
-      expect(instance.nonterminals).to eq([expr_symb, foo_symb])
-    end
-  end # context
-
-  context 'Errors:' do
-    it 'fails when initialized with one alternative only' do
-      err = StandardError
-      err_msg = 'The choice for `expression` must have at least two alternatives.'
-      expect { described_class.new(expr_symb, [alt1]) }.to raise_error(err, err_msg)
-    end
-
-    it 'fails in presence of duplicate rhs' do
-      err = StandardError
-      err_msg = 'Duplicate alternatives: expression => NUMBER PLUS NUMBER'
-      expect { described_class.new(expr_symb, [alt1, alt2, alt1]) }.to raise_error(err, err_msg)
-    end
-  end # context
-end # describe

data/spec/dendroid/syntax/production_spec.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '..\..\spec_helper'
-require_relative '..\..\..\lib\dendroid\syntax\terminal'
-require_relative '..\..\..\lib\dendroid\syntax\non_terminal'
-require_relative '..\..\..\lib\dendroid\syntax\symbol_seq'
-require_relative '..\..\..\lib\dendroid\syntax\production'
-
-describe Dendroid::Syntax::Production do
-  let(:num_symb) { Dendroid::Syntax::Terminal.new('NUMBER') }
-  let(:plus_symb) { Dendroid::Syntax::Terminal.new('PLUS') }
-  let(:expr_symb) { Dendroid::Syntax::NonTerminal.new('expression') }
-  let(:foo_symb) { Dendroid::Syntax::NonTerminal.new('foo') }
-  let(:rhs) { Dendroid::Syntax::SymbolSeq.new([num_symb, plus_symb, num_symb]) }
-  let(:cyclic_rhs) { Dendroid::Syntax::SymbolSeq.new([foo_symb]) }
-  let(:empty_body) { Dendroid::Syntax::SymbolSeq.new([]) }
-
-  # Implements a production rule: expression => NUMBER PLUS NUMBER
-  subject { described_class.new(expr_symb, rhs) }
-
-  context 'Initialization:' do
-    it 'is initialized with a head and a body' do
-      expect { described_class.new(expr_symb, rhs) }.not_to raise_error
-    end
-
-    it 'knows its body (aka rhs)' do
-      expect(subject.body).to eq(rhs)
-    end
-
-    it 'renders a String representation of itself' do
-      expect(subject.to_s).to eq('expression => NUMBER PLUS NUMBER')
-    end
-  end # context
-
-  context 'Provided services:' do
-    it 'knows whether its body empty is empty or not' do
-      expect(described_class.new(expr_symb, empty_body).empty?).to be_truthy
-      expect(subject.empty?).to be_falsey
-    end
-
-    it 'knows its non-terminal members' do
-      foo_rhs = Dendroid::Syntax::SymbolSeq.new([expr_symb, plus_symb, expr_symb])
-      instance = described_class.new(foo_symb, foo_rhs)
-      expect(instance.nonterminals).to eq([expr_symb])
-    end
-
-    it 'knows its terminal members' do
-      expect(subject.terminals).to eq([num_symb, plus_symb])
-    end
-
-    # rubocop: disable Lint/BinaryOperatorWithIdenticalOperands
-    it 'can compare with another production' do
-      expect(subject == subject).to be_truthy
-
-      same = described_class.new(expr_symb, rhs)
-      expect(subject == same).to be_truthy
-
-      # Different lhs, same rhs
-      different_lhs = described_class.new(foo_symb, rhs)
-      expect(subject == different_lhs).to be_falsey
-
-      # Same lhs, different rhs
-      different_rhs = described_class.new(expr_symb, empty_body)
-      expect(subject == different_rhs).to be_falsey
-
-      # Two productions with same lhs and empty bodies
-      empty = described_class.new(expr_symb, empty_body)
-      void = described_class.new(expr_symb, Dendroid::Syntax::SymbolSeq.new([]))
-      expect(empty == void).to be_truthy
-
-      # Two productions with distinct lhs and empty bodies
-      empty = described_class.new(expr_symb, empty_body)
-      void = described_class.new(foo_symb, Dendroid::Syntax::SymbolSeq.new([]))
-      expect(empty == void).to be_falsey
-    end
-    # rubocop: enable Lint/BinaryOperatorWithIdenticalOperands
-  end # context
-
-  context 'Errors:' do
-    it "fails when rhs isn't initialized with a SymbolSeq" do
-      err = StandardError
-      err_msg = 'Expecting a SymbolSeq, found a String instead.'
-      expect { described_class.new(foo_symb, 'bad') }.to raise_error err, err_msg
-    end
-
-    it 'fails when the production is cyclic' do
-      err = StandardError
-      err_msg = 'Cyclic rules of the kind foo => foo are not allowed.'
-      expect { described_class.new(foo_symb, cyclic_rhs) }.to raise_error err, err_msg
-    end
-  end # context
-end # describe