rley 0.8.01 → 0.8.02

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5652efd2016050e7a40a94c279fa545a03b69b705bdcc5089a479d72c4743325
-  data.tar.gz: c3f46ba853632a95e3c1fbe16f0f77f8e8a07ed3acd69a82297ca13eec9b6ccc
+  metadata.gz: 490bce9cb193d9e7b49222e8e1bae90d0dba64e663990cacef56ea69881c418a
+  data.tar.gz: 2f9380c53ff442992acb2629ab1f197078e0b403f373a2ed394a1cbfca85bc2c
 SHA512:
-  metadata.gz: 532ca6d76a277e6fd234d66ec74e9ade425a91f8ace039e0dc0636547663ac52f64613001e9c36497d5a0e0d9fe67f09eb2fff80b77d8c2f4950095e58ac3b2e
-  data.tar.gz: b288a0345c1696b8987b362ab99dafa4354f94ece73c5c80c87d7a28aa3c3d9ccaf0f516f29cead1707727582e917812435e4254e372aa2d62c110af7aa99a99
+  metadata.gz: 0b1ffe315ef7ddbb50e18244e233320ac592347997a7a84ce55545d24564e39aeeda56f5002e4645cac54e7e91dfa1ac79bc0567592e84720113622e3976539e
+  data.tar.gz: e7272a73b9f2359564d6783a5b0d8f38564ea9788cd7e568a4207de0176233bf0b29f7b37be991dc039dea45e5795d2eb59f7e8751940302c59d02dc23f33b85

data/.rubocop.yml

@@ -1,7 +1,7 @@
 AllCops:
   Exclude:
-    - 'exp/**/*'
-    - 'demo/**/*'
+    - 'examples/**/*'
+    - 'exp/**/*'    
 
 Gemspec/DateAssignment:
   Enabled: true
@@ -50,6 +50,9 @@ Layout/IndentationConsistency:
 Layout/HeredocIndentation:
   Enabled: false
 
+Layout/LineEndStringConcatenationIndentation:
+  Enabled: true
+
 Layout/MultilineHashBraceLayout:
   Enabled: true
 
@@ -81,6 +84,9 @@ Layout/TrailingWhitespace:
 Lint/AmbiguousAssignment:
   Enabled: true
 
+Lint/AmbiguousRange:
+  Enabled: true
+
 Lint/DeprecatedConstants:
   Enabled: true
 
@@ -96,6 +102,9 @@ Lint/EmptyBlock:
 Lint/EmptyClass:
   Enabled: false
 
+Lint/EmptyInPattern:
+  Enabled: true
+
 Lint/LambdaWithoutLiteralBlock:
   Enabled: true
 
@@ -192,6 +201,9 @@ Naming/ClassAndModuleCamelCase:
 Naming/BlockParameterName:
   Enabled: true
 
+Naming/InclusiveLanguage:
+  Enabled: true
+
 Naming/MethodParameterName:
   Enabled: false
 
@@ -201,9 +213,6 @@ Naming/MethodName:
 Naming/VariableName:
   Enabled: false
 
-Style/AccessorGrouping:
-  Enabled: false
-
 Style/Alias:
   Enabled: true
 
@@ -276,11 +285,17 @@ Style/HashTransformValues:
 Style/IfUnlessModifier:
   Enabled: false
 
+Style/InPatternThen:
+  Enabled: true
+
 Style/InverseMethods:
   Enabled: false
 
 Style/MissingRespondToMissing:
   Enabled: false
+  
+Style/MultilineInPatternThen:
+  Enabled: true  
 
 Style/NegatedIfElseCondition:
   Enabled: true
@@ -293,6 +308,9 @@ Style/NilLambda:
 
 Style/NumericLiterals:
   Enabled: false
+  
+Style/QuotedSymbols:
+  Enabled: true  
 
 Style/RaiseArgs:
   Enabled: true
@@ -305,6 +323,9 @@ Style/RedundantReturn:
 
 Style/RedundantSelf:
   Enabled: true
+  
+Style/RedundantSelfAssignmentBranch:
+  Enabled: true  
 
 Style/RegexpLiteral:
   Enabled: false
@@ -367,6 +388,9 @@ Lint/TopLevelReturnWithArgument:
 Lint/UnreachableLoop:
   Enabled: true
 
+Style/AccessorGrouping:
+  Enabled: true
+
 Style/ArrayCoercion:
   Enabled: true
 

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+### 0.8.02 / 2021-08-23
+- Code restyling to please Rubocop 1.19.1
+
+* [CHANGE] File `.rubocp.yml` updated to take into account new cops.
+* [CHANGE] File `*.rb` files updated to fix Rubocop findings
+
+
 ### 0.8.01 / 2021-08-22
 - Unused/redundant file removal. Fix in rule generation
 

data/examples/NLP/pico_en_demo.rb

@@ -26,8 +26,8 @@ engine.build_grammar do
   rule 'S' => 'NP VP'
   rule 'NP' => 'Proper-Noun'
   rule 'NP' => 'Determiner Noun'
-  rule 'NP' => 'Determiner Noun PP'  
-  rule 'VP' => 'Verb NP'  
+  rule 'NP' => 'Determiner Noun PP'
+  rule 'VP' => 'Verb NP'
   rule 'VP' => 'Verb NP PP'
   rule 'PP' => 'Preposition NP'
 end

data/lib/rley/constants.rb

@@ -5,7 +5,7 @@
 
 module Rley # Module used as a namespace
   # The version number of the gem.
-  Version = '0.8.01'
+  Version = '0.8.02'
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm"

data/lib/rley/notation/all_notation_nodes.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require_relative 'grouping_node'
-require_relative 'symbol_node'
+require_relative 'symbol_node'

data/lib/rley/notation/ast_builder.rb

@@ -1,191 +1,185 @@
-# frozen_string_literal: true
-
-require_relative '../parse_rep/ast_base_builder'
-require_relative '../engine'
-require_relative 'all_notation_nodes'
-
-module Rley
-  module Notation
-    # The purpose of ASTBuilder is to build piece by piece an AST
-    # (Abstract Syntax Tree) from a sequence of input tokens and
-    # visit events produced by walking over a GFGParsing object.
-    class ASTBuilder < Rley::ParseRep::ASTBaseBuilder
-      unless defined?(Name2special)
-        # Mapping Token name => operator | separator | delimiter characters
-        # @return [Hash{String => String}]
-        Name2special = {
-          'COMMA' =>  ',',
-          'ELLIPSIS' => '..',
-          'LEFT_BRACE' =>  '{',
-          'LEFT_PAREN' => '(',
-          'PLUS' => '+',
-          'QUESTION_MARK' => '?',
-          'RIGHT_BRACE' => '}',
-          'RIGHT_PAREN' => ')',
-          'STAR' => '*'
-        }.freeze
-      end
-
-      # Create a new AST builder instance.
-      # @param theTokens [Array<Rley::Lexical::Token>] The sequence of input tokens.
-      def initialize(theTokens)
-        super(theTokens)
-      end
-
-      protected
-
-      def terminal2node
-        Terminal2NodeClass
-      end
-
-      # Method override
-      def new_leaf_node(_production, _terminal, aTokenPosition, aToken)
-        Rley::PTree::TerminalNode.new(aToken, aTokenPosition)
-      end
-
-      # Factory method for creating a parent node object.
-      # @param aProduction [Production] Production rule
-      # @param aRange [Range] Range of tokens matched by the rule
-      # @param theTokens [Array] The input tokens
-      # @param theChildren [Array] Children nodes (one per rhs symbol)
-      def new_parent_node(aProduction, aRange, theTokens, theChildren)
-        mth_name = method_name(aProduction.name)
-        if respond_to?(mth_name, true)
-          node = send(mth_name, aProduction, aRange, theTokens, theChildren)
-        else
-          # Default action...
-          node = case aProduction.rhs.size
-                 when 0
-                   return_epsilon(aRange, theTokens, theChildren)
-                 when 1
-                   return_first_child(aRange, theTokens, theChildren)
-                 else
-                   node = Rley::PTree::NonTerminalNode.new(aProduction.lhs, aRange)
-                   theChildren&.reverse_each do |child|
-                     node.add_subnode(child) if child
-                   end
-
-                   node
-                 end
-        end
-
-        node
-      end
-
-      # Return the AST node corresponding to the second symbol in the rhs
-      def reduce_to_2nd_symbol(_production, _range, _tokens, theChildren)
-        theChildren[1]
-      end
-
-      #####################################
-      #  SEMANTIC ACTIONS
-      #####################################
-
-      # rule('rhs' => 'member_seq').tag 'sequence'
-      def reduce_sequence(_production, _range, _tokens, theChildren)
-        if theChildren[0].size == 1
-          theChildren[0].first
-        else
-          SequenceNode.new(theChildren[0].first.position, theChildren[0], nil)
-        end
-      end
-
-      # rule('member_seq' => 'member_seq member').tag 'more_members'
-      def reduce_more_members(_production, _range, _tokens, theChildren)
-        theChildren[0] << theChildren[1]
-      end
-
-      # rule('member_seq' => 'member')
-      def reduce_one_member(_production, _range, _tokens, theChildren)
-        [theChildren[0]]
-      end
-
-      # rule('strait_member' => 'base_member annotation')
-      def reduce_annotated_member(_production, _range, _tokens, theChildren)
-        theChildren[0].annotation = theChildren[1]
-
-        theChildren[0]
-      end
-
-      # rule('base_member' => 'SYMBOL')
-      def reduce_symbol(_production, _range, _tokens, theChildren)
-        SymbolNode.new(theChildren[0].token.position, theChildren[0].token.lexeme)
-      end
-
-      # rule('base_member' => 'LEFT_PAREN member_seq RIGHT_PAREN')
-      def reduce_grouping(_production, _range, tokens, theChildren)
-        if theChildren[1].size == 1
-          theChildren[1].first
-        else
-          rank = theChildren[0].range.high
-          pos = tokens[rank].position
-          GroupingNode.new(pos, theChildren[1], nil)
-        end
-      end
-
-      # rule('quantified_member' => 'base_member quantifier')
-      def reduce_quantified_member(_production, _range, _tokens, theChildren)
-        theChildren[0].repetition = theChildren[1]
-        theChildren[0]
-      end
-
-      # rule('quantifier' => 'QUESTION_MARK')
-      def reduce_question_mark(_production, _range, _tokens, _theChildren)
-        :zero_or_one
-      end
-
-      # rule('quantifier' => 'STAR')
-      def reduce_star(_production, _range, _tokens, _theChildren)
-        :zero_or_more
-      end
-
-      # rule('quantifier' => 'PLUS')
-      def reduce_plus(_production, _range, _tokens, _theChildren)
-        :one_or_more
-      end
-
-      # rule('annotation' => 'LEFT_BRACE mapping RIGHT_BRACE').tag ''
-      def reduce_annotation(_production, _range, _tokens, theChildren)
-        theChildren[1]
-      end
-
-      # rule('mapping' => 'mapping COMMA key_value')
-      def reduce_more_pairs(_production, _range, _tokens, theChildren)
-        hsh = theChildren[0]
-        hsh[theChildren[2].first] = theChildren[2].last
-
-        hsh
-      end
-
-      # rule('mapping' => 'key_value').tag 'one_pair'
-      def reduce_one_pair(_production, _range, _tokens, theChildren)
-        { theChildren[0].first => theChildren[0].last }
-      end
-
-      # rule('key_value' => 'KEY value')
-      def reduce_raw_pair(_production, _range, _tokens, theChildren)
-        key = theChildren[0].token.lexeme
-        value = if theChildren[1].kind_of?(Rley::PTree::TerminalNode)
-                  theChildren[1].token.lexeme
-                else
-                  theChildren[1]
-                end
-        [key, value]
-      end
-
-      # rule('range' => 'INT_LIT ELLIPSIS INT_LIT')
-      def reduce_bound_range(_production, _range, _tokens, theChildren)
-        low = theChildren[0].token.lexeme
-        high = theChildren[2].token.lexeme
-        case [low, high]
-          when ['0', '1']
-            :zero_or_one
-          when ['1', '1']
-            :exactly_one
-          else
-            Range.new(low.to_i, high.to_i)
-        end
-      end
-    end # class
-  end # module
-end # module
+# frozen_string_literal: true
+
+require_relative '../parse_rep/ast_base_builder'
+require_relative '../engine'
+require_relative 'all_notation_nodes'
+
+module Rley
+  module Notation
+    # The purpose of ASTBuilder is to build piece by piece an AST
+    # (Abstract Syntax Tree) from a sequence of input tokens and
+    # visit events produced by walking over a GFGParsing object.
+    class ASTBuilder < Rley::ParseRep::ASTBaseBuilder
+      unless defined?(Name2special)
+        # Mapping Token name => operator | separator | delimiter characters
+        # @return [Hash{String => String}]
+        Name2special = {
+          'COMMA' =>  ',',
+          'ELLIPSIS' => '..',
+          'LEFT_BRACE' =>  '{',
+          'LEFT_PAREN' => '(',
+          'PLUS' => '+',
+          'QUESTION_MARK' => '?',
+          'RIGHT_BRACE' => '}',
+          'RIGHT_PAREN' => ')',
+          'STAR' => '*'
+        }.freeze
+      end
+
+      protected
+
+      def terminal2node
+        Terminal2NodeClass
+      end
+
+      # Method override
+      def new_leaf_node(_production, _terminal, aTokenPosition, aToken)
+        Rley::PTree::TerminalNode.new(aToken, aTokenPosition)
+      end
+
+      # Factory method for creating a parent node object.
+      # @param aProduction [Production] Production rule
+      # @param aRange [Range] Range of tokens matched by the rule
+      # @param theTokens [Array] The input tokens
+      # @param theChildren [Array] Children nodes (one per rhs symbol)
+      def new_parent_node(aProduction, aRange, theTokens, theChildren)
+        mth_name = method_name(aProduction.name)
+        if respond_to?(mth_name, true)
+          node = send(mth_name, aProduction, aRange, theTokens, theChildren)
+        else
+          # Default action...
+          node = case aProduction.rhs.size
+                 when 0
+                   return_epsilon(aRange, theTokens, theChildren)
+                 when 1
+                   return_first_child(aRange, theTokens, theChildren)
+                 else
+                   node = Rley::PTree::NonTerminalNode.new(aProduction.lhs, aRange)
+                   theChildren&.reverse_each do |child|
+                     node.add_subnode(child) if child
+                   end
+
+                   node
+                 end
+        end
+
+        node
+      end
+
+      # Return the AST node corresponding to the second symbol in the rhs
+      def reduce_to_2nd_symbol(_production, _range, _tokens, theChildren)
+        theChildren[1]
+      end
+
+      #####################################
+      #  SEMANTIC ACTIONS
+      #####################################
+
+      # rule('rhs' => 'member_seq').tag 'sequence'
+      def reduce_sequence(_production, _range, _tokens, theChildren)
+        if theChildren[0].size == 1
+          theChildren[0].first
+        else
+          SequenceNode.new(theChildren[0].first.position, theChildren[0], nil)
+        end
+      end
+
+      # rule('member_seq' => 'member_seq member').tag 'more_members'
+      def reduce_more_members(_production, _range, _tokens, theChildren)
+        theChildren[0] << theChildren[1]
+      end
+
+      # rule('member_seq' => 'member')
+      def reduce_one_member(_production, _range, _tokens, theChildren)
+        [theChildren[0]]
+      end
+
+      # rule('strait_member' => 'base_member annotation')
+      def reduce_annotated_member(_production, _range, _tokens, theChildren)
+        theChildren[0].annotation = theChildren[1]
+
+        theChildren[0]
+      end
+
+      # rule('base_member' => 'SYMBOL')
+      def reduce_symbol(_production, _range, _tokens, theChildren)
+        SymbolNode.new(theChildren[0].token.position, theChildren[0].token.lexeme)
+      end
+
+      # rule('base_member' => 'LEFT_PAREN member_seq RIGHT_PAREN')
+      def reduce_grouping(_production, _range, tokens, theChildren)
+        if theChildren[1].size == 1
+          theChildren[1].first
+        else
+          rank = theChildren[0].range.high
+          pos = tokens[rank].position
+          GroupingNode.new(pos, theChildren[1], nil)
+        end
+      end
+
+      # rule('quantified_member' => 'base_member quantifier')
+      def reduce_quantified_member(_production, _range, _tokens, theChildren)
+        theChildren[0].repetition = theChildren[1]
+        theChildren[0]
+      end
+
+      # rule('quantifier' => 'QUESTION_MARK')
+      def reduce_question_mark(_production, _range, _tokens, _theChildren)
+        :zero_or_one
+      end
+
+      # rule('quantifier' => 'STAR')
+      def reduce_star(_production, _range, _tokens, _theChildren)
+        :zero_or_more
+      end
+
+      # rule('quantifier' => 'PLUS')
+      def reduce_plus(_production, _range, _tokens, _theChildren)
+        :one_or_more
+      end
+
+      # rule('annotation' => 'LEFT_BRACE mapping RIGHT_BRACE').tag ''
+      def reduce_annotation(_production, _range, _tokens, theChildren)
+        theChildren[1]
+      end
+
+      # rule('mapping' => 'mapping COMMA key_value')
+      def reduce_more_pairs(_production, _range, _tokens, theChildren)
+        hsh = theChildren[0]
+        hsh[theChildren[2].first] = theChildren[2].last
+
+        hsh
+      end
+
+      # rule('mapping' => 'key_value').tag 'one_pair'
+      def reduce_one_pair(_production, _range, _tokens, theChildren)
+        { theChildren[0].first => theChildren[0].last }
+      end
+
+      # rule('key_value' => 'KEY value')
+      def reduce_raw_pair(_production, _range, _tokens, theChildren)
+        key = theChildren[0].token.lexeme
+        value = if theChildren[1].kind_of?(Rley::PTree::TerminalNode)
+                  theChildren[1].token.lexeme
+                else
+                  theChildren[1]
+                end
+        [key, value]
+      end
+
+      # rule('range' => 'INT_LIT ELLIPSIS INT_LIT')
+      def reduce_bound_range(_production, _range, _tokens, theChildren)
+        low = theChildren[0].token.lexeme
+        high = theChildren[2].token.lexeme
+        case [low, high]
+          when %w[0 1]
+            :zero_or_one
+          when %w[1 1]
+            :exactly_one
+          else
+            Range.new(low.to_i, high.to_i)
+        end
+      end
+    end # class
+  end # module
+end # module