dendroid 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23f7c3fcf4a7f0df335e5b2fbc7f25f89a60f4d66cc9bfd1ce37680fbb133b83
-  data.tar.gz: fc4a399d2a5812d4c0e01b28bc261e810386b3d54c353ba2e54190d3df508e3f
+  metadata.gz: a28b9efefb235a669b37c24f587704cc94b7a10f411eafdeef418094013abfc2
+  data.tar.gz: 1e316ac1c14b8b81ee2a3acf96a3f04d3e772e72f0a062976150ea5def7080f6
 SHA512:
-  metadata.gz: c4f9ec0db43dcf581d2c5a3866fb383f757bd0a99b4526348b41326a22b0c39b04200768b1cb7a1dfd03ae3272d60de0fc09f73c9a7d9df3269bdf1721f8f19b
-  data.tar.gz: dd5a819b7946149c38e39822489d2ef08838abb87f6f6e549e2dbade55fa77edf99d91503664506bfe0b07a5c66d5408a7b409c0b090297f70d488696ecd88bc
+  metadata.gz: 72b4df1de4b537b3bb5ae1d00f56a7cde86627c5b5b2205390a02c824809bfd81ee493ee70ca01d08ea3874e9dc04beb66f09366b186fb133a4250e426281553
+  data.tar.gz: 5cb5126a0f116d86a91f2a2138dac2330bfaf3911548324947196d768e0ec4e45a897360ce2ab3d31e48497bd24e2fdefdbfc365c28dda5f953f20ea3a16a563

data/.rubocop.yml

@@ -1,3 +1,7 @@
+Layout/EndOfLine:
+  Enabled: true
+  EnforcedStyle: lf
+
 Metrics/BlockLength:
   Enabled: true
   Max: 50

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/lib/dendroid/syntax/rule.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Dendroid
+  module Syntax
+    # In a context-free grammar, a rule has its left-hand side (LHS)
+    # that consists solely of one non-terminal symbol.
+    # and the right-hand side (RHS) consists of one or more sequence of symbols.
+    # The symbols in RHS can be either terminal or non-terminal symbols.
+    # The rule stipulates that the LHS is equivalent to the RHS,
+    # in other words every occurrence of the LHS can be substituted to
+    # corresponding RHS.
+    class Rule
+      # @return [Dendroid::Syntax::NonTerminal] The left-hand side of the rule.
+      attr_reader :head
+      alias lhs head
+
+      # Create a Rule instance.
+      # @param lhs [Dendroid::Syntax::NonTerminal] The left-hand side of the rule.
+      def initialize(lhs)
+        @head = valid_head(lhs)
+      end
+
+      # Return the text representation of the rule
+      # @return [String]
+      def to_s
+        head.to_s
+      end
+
+      # The set of all grammar symbols that occur in the rhs.
+      # @return [Array<Dendroid::Syntax::GrmSymbol>]
+      def rhs_symbols
+        symbols = rhs.reduce([]) do |result, alt|
+          result.concat(alt.members)
+        end
+        symbols.uniq
+      end
+
+      # The set of all non-terminal symbols that occur in the rhs.
+      # @return [Array<Dendroid::Syntax::NonTerminal>]
+      def nonterminals
+        rhs_symbols.reject(&:terminal?)
+      end
+
+      # The set of all terminal symbols that occur in the rhs.
+      # @return [Array<Dendroid::Syntax::Terminal>]
+      def terminals
+        rhs_symbols.select(&:terminal?)
+      end
+
+      private
+
+      def valid_head(lhs)
+        if lhs.terminal?
+          err_msg = "Terminal symbol '#{lhs}' may not be on left-side of a rule."
+          raise StandardError, err_msg
+        end
+
+        lhs
+      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/spec/dendroid/syntax/rule_spec.rb

@@ -0,0 +1,23 @@
+# 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\rule'
+
+describe Dendroid::Syntax::Rule do
+  let(:num_symb) { Dendroid::Syntax::Terminal.new('NUMBER') }
+  let(:expr_symb) { Dendroid::Syntax::NonTerminal.new('expression') }
+
+  subject { described_class.new(expr_symb) }
+
+  context 'Initialization:' do
+    it 'is initialized with a non-terminal' do
+      expect { described_class.new(expr_symb) }.not_to raise_error
+    end
+
+    it 'knows its head (aka lhs)' do
+      expect(subject.head).to eq(expr_symb)
+    end
+  end # context
+end # describe

data/version.txt

@@ -1 +1 @@
-0.0.2
+0.0.4

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dendroid
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Dimitri Geshef
@@ -25,10 +25,14 @@ 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
 - spec/spec_helper.rb