dendroid 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 869334c2ae25a3765d7105eca383f1ba89162ae9a9446a2b5268a0d463261cc7
-  data.tar.gz: 7811bca0c671959b90618a8e667c57da65ed2c5d8ccc4171a86e0c8a3a80a6c0
+  metadata.gz: e94a9721000d8e9a45184107ec3488a3dad0c92337507c6753d4cbfa973400fd
+  data.tar.gz: 03bbe70d73b5e12de42b5dca4f008f1850fb9efcc4272115e5123c7397984f4a
 SHA512:
-  metadata.gz: 582c360f25cab435de732a6a7837461302a4af9325f6ddf93448be3c9f674acf59c05e6aa756d21a7ea805c1c55373bed298c4c659844fb67781f51c3444bf67
-  data.tar.gz: 52a3e9325988a534998dbbfb35471220c087702f7a97df0acc77c62ef55202be4cb5a858fe16e77ee525f4bfb98ff6fa7756fb99689ce980a8e02cd38ab24aa0
+  metadata.gz: 8dde1d9509f2d713db092e5730a1c37f1aaab2a1a58b45cb46c3e28011e672d6c27d9e630262d96a5e5597de35b9278aab8b6e2b87934bf4840e024eee0d6bea
+  data.tar.gz: d927b08bf68f6c2a128c92c4724a533991799acf207cd13c381d4abea4cbbf8b340de17771c0a41c351bed3a0d6ac2cd523990d1c0bb699824ce14b9ccd97fe6

data/CHANGELOG.md

@@ -0,0 +1,38 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.0.5] - 2023-10-28
+### Added
+- Class `Choice` and its spec file
+
+### Fixed
+- File `dendroid.gemspec`: added missing `CHANGELOG.md` in the package
+
+## [0.0.4] - 2023-10-28
+### Added
+- Class `Production` and its spec file
+
+## [0.0.3] - 2023-10-28
+### Added
+- Class `Rule` and its spec file
+
+## [0.0.2] - 2023-10-28
+### Added
+- Class `SymbolSeq` and its spec file
+- File `CHANGELOG.md`; the file file you're reading now.
+
+### Changed
+- Line separator set to lf (line feed)
+- Code re-styling to please Rubocop 1.57.1
+
+## [0.0.1] - 2023-10-27
+### Added
+- Class `NonTerminal` and its spec file
+
+## [0.0.0] - 2023-10-27
+- Initial commit
+
+### Added
+- Class `GrmSymbol` and its spec file
+- Class `Terminal` and its spec file

data/dendroid.gemspec

@@ -16,6 +16,7 @@ Gem::Specification.new do |s|
                       'lib/**/*.rb',
                       'spec/**/*.rb',
                       '.rubocop.yml',
+                      'CHANGELOG.md',
                       'dendroid.gemspec',
                       'LICENSE',
                       'Rakefile',

data/lib/dendroid/syntax/choice.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative 'rule'
+
+module Dendroid
+  module Syntax
+    # A specialization of the Rule class.
+    # A choice is a rule with multiple rhs
+    class Choice < Rule
+      # @return [Array<Dendroid::Syntax::SymbolSeq>]
+      attr_reader :alternatives
+
+      # Create a Choice instance.
+      # @param lhs [Dendroid::Syntax::NonTerminal] The left-hand side of the rule.
+      # @param alt [Array<Dendroid::Syntax::SymbolSeq>] the alternatives (each as a sequence of symbols).
+      def initialize(lhs, alt)
+        super(lhs)
+        @alternatives = valid_alternatives(alt)
+      end
+
+      # Predicate method to check whether the rule has alternatives
+      # @return [TrueClass]
+      def choice?
+        true
+      end
+
+      # Return the text representation of the choice
+      # @return [String]
+      def to_s
+        "#{head} => #{alternatives.join(' | ')}"
+      end
+
+      # Predicate method to check whether the choice rule body is productive.
+      # It is productive when at least of its alternative is productive.
+      # @return [Boolean]
+      def productive?
+        productive_alts = alternatives.select(&:productive?)
+        return false if productive_alts.empty?
+
+        @productive = Set.new(productive_alts)
+        head.productive = true
+      end
+
+      # Predicate method to check whether the rule has at least one empty alternative.
+      # @return [Boolean]
+      def empty?
+        alternatives.any?(&:empty?)
+      end
+
+      # Returns an array with the symbol sequence of its alternatives
+      # @return [Array<Dendroid::Syntax::SymbolSeq>]
+      def rhs
+        alternatives
+      end
+
+      # Equality operator
+      # Two production rules are equal when their head and alternatives are equal.
+      # @return [Boolean]
+      def ==(other)
+        return true if equal?(other)
+        return false if other.is_a?(Production)
+
+        (head == other.head) && (alternatives == other.alternatives)
+      end
+
+      private
+
+      def valid_alternatives(alt)
+        if alt.size < 2
+          # A choice must have at least two alternatives
+          raise StandardError.new, "The choice for #{lhs} must have at least two alternatives."
+        end
+
+        cyclic = alt.find { |a| a.size == 1 && lhs == a.first }
+        if cyclic
+          # Forbid cyclic rules (e.g. A => A)
+          raise StandardError.new, "Cyclic rule of the kind #{lhs} => #{lhs} is not allowed."
+        end
+
+        alt
+      end
+    end # class
+  end # module
+end # module

data/lib/dendroid/syntax/production.rb

@@ -0,0 +1,93 @@
+# 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_body(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 valid_body(rhs)
+        raise StandardError unless rhs.is_a?(SymbolSeq)
+
+        if rhs.size == 1 && lhs == rhs.first
+          # Forbid cyclic rules (e.g. A => A)
+          raise StandardError.new, "Cyclic rule of the kind #{lhs} => #{lhs} is not allowed."
+        end
+
+        rhs
+      end
+
+      def productive=(val)
+        @productive = val
+        lhs.productive = val
+      end
+    end # class
+  end # module
+end # module

data/spec/dendroid/syntax/choice_spec.rb

@@ -0,0 +1,54 @@
+# 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
+end # describe

data/spec/dendroid/syntax/production_spec.rb

@@ -0,0 +1,77 @@
+# 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(: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
+end # describe

data/version.txt

@@ -1 +1 @@
-0.0.3
+0.0.5

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dendroid
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Dimitri Geshef
@@ -17,19 +17,24 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rubocop.yml"
+- CHANGELOG.md
 - LICENSE
 - README.md
 - Rakefile
 - bin/dendroid
 - dendroid.gemspec
 - lib/dendroid/dendroid.rb
+- lib/dendroid/syntax/choice.rb
 - lib/dendroid/syntax/grm_symbol.rb
 - lib/dendroid/syntax/non_terminal.rb
+- lib/dendroid/syntax/production.rb
 - lib/dendroid/syntax/rule.rb
 - lib/dendroid/syntax/symbol_seq.rb
 - lib/dendroid/syntax/terminal.rb
+- spec/dendroid/syntax/choice_spec.rb
 - spec/dendroid/syntax/grm_symbol_spec.rb
 - spec/dendroid/syntax/non_terminal_spec.rb
+- spec/dendroid/syntax/production_spec.rb
 - spec/dendroid/syntax/rule_spec.rb
 - spec/dendroid/syntax/symbol_seq_spec.rb
 - spec/dendroid/syntax/terminal_spec.rb