dendroid 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 869334c2ae25a3765d7105eca383f1ba89162ae9a9446a2b5268a0d463261cc7
-  data.tar.gz: 7811bca0c671959b90618a8e667c57da65ed2c5d8ccc4171a86e0c8a3a80a6c0
+  metadata.gz: a28b9efefb235a669b37c24f587704cc94b7a10f411eafdeef418094013abfc2
+  data.tar.gz: 1e316ac1c14b8b81ee2a3acf96a3f04d3e772e72f0a062976150ea5def7080f6
 SHA512:
-  metadata.gz: 582c360f25cab435de732a6a7837461302a4af9325f6ddf93448be3c9f674acf59c05e6aa756d21a7ea805c1c55373bed298c4c659844fb67781f51c3444bf67
-  data.tar.gz: 52a3e9325988a534998dbbfb35471220c087702f7a97df0acc77c62ef55202be4cb5a858fe16e77ee525f4bfb98ff6fa7756fb99689ce980a8e02cd38ab24aa0
+  metadata.gz: 72b4df1de4b537b3bb5ae1d00f56a7cde86627c5b5b2205390a02c824809bfd81ee493ee70ca01d08ea3874e9dc04beb66f09366b186fb133a4250e426281553
+  data.tar.gz: 5cb5126a0f116d86a91f2a2138dac2330bfaf3911548324947196d768e0ec4e45a897360ce2ab3d31e48497bd24e2fdefdbfc365c28dda5f953f20ea3a16a563

data/lib/dendroid/syntax/production.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative 'rule'
+
+module Dendroid
+  module Syntax
+    # A specialization of the Rule class.
+    # A production is the unique rule for the non-terminal symbol
+    # at its left-hand side (lhs).
+    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/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.4

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dendroid
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Dimitri Geshef
@@ -25,11 +25,13 @@ files:
 - lib/dendroid/dendroid.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/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