sequitur 0.1.26 → 0.1.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86e5e7a51109f635607be37902ce3edf561b204119005eea6baa0f90d1dc90b8
-  data.tar.gz: 686f7ed1ba3e76ab16f06b891809025afd7b020009b3a67cba7600f4c66c18cc
+  metadata.gz: c4f8d643f0d20e27fa1f36c2334d4fdb1ff749710aa382d8a0b9553ef2180191
+  data.tar.gz: a0db266b1a501f9c7b386a23eb99b60231a37d564eefc115a86df877469a5ef3
 SHA512:
-  metadata.gz: ff134c984fe467059df107491030b84cfd1c73aca32ef78eca7fca90a5f207db06c552dab126e12e81eb97537789b6d24c36cdf79af0e7934fcf42ff17c818b1
-  data.tar.gz: b6c909ca88b6031252c53f11d4e07babae1c0fe0f3b146d50e0aaea55be7befa5a4fdf8ac456c8da76ecac0cfe579f41f939cdb569c605e9da6fb491d5182991
+  metadata.gz: c0b09c07ccbd6b60011d5bd0e38e2031e3b78e017181c8fac9918a16f921d3bd52f674635cdfe6ec54bacca0a7e5443b378b3f4f3a6aea65bcef488006983b1a
+  data.tar.gz: 687acbb729d94875e77a05420f1d9822e4bfa7ae86d49dc82a7422e51c7086d6222b906b13518e2f76b1bb78b24245ee6f580e9bce212c2916432b07813aeab7

data/.yardopts

@@ -2,5 +2,5 @@
 --no-private
 --markup markdown
 -
-Changelog.md
-License.txt
+CHANGELOG.md
+LICENSE.txt

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [0.1.27] - 2025-02-16
+Credits to `gemmaro` for the improvements:
+- Enhancements to document generation with YARD.
+- Updates to the `gemspec` and `Gemfile`.
+- Improved `README.md` markup for better rendering with YARD and on the GitHub repository page.
+
+## [0.1.26] - 2025-02-15
+- Tested against MRI Ruby 3.4.1
+- Version of dependencies updated
+
 ## [0.1.25] - 2023-07-10
 - First version using RBS (Ruby Type System): new folder `sig` with `*.rbs` files
 - Yard documentation updated to align with RBS

data/Gemfile

@@ -1,9 +1,4 @@
 # frozen_string_literal: true
 
 source 'https://rubygems.org'
-# Prevent Bundler to load the dependencies from our .gemspec file
-
-group :development do
-  gem 'rake', '>= 13.1.0'
-  gem 'rspec', '>= 3.10.0'
-end
+gemspec

data/README.md

@@ -11,14 +11,15 @@ _Ruby gem implementing the Sequitur algorithm_
 [![License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](https://github.com/famished-tiger/Sequitur/blob/master/LICENSE.txt)
 
 ### What is the Sequitur algorithm? ###
-The following are good entry points to learn about the algorithm:  
-[Sequitur algorithm home](http://sequitur.info/)  
-[Wikipedia](http://en.wikipedia.org/wiki/Sequitur_algorithm)  
+The following are good entry points to learn about the algorithm:
+
+* [Sequitur algorithm home](http://sequitur.info/)  
+* [Wikipedia](http://en.wikipedia.org/wiki/Sequitur_algorithm)  
 
 ### Highlights ###
 * Pure Ruby implementation
 * No runtime dependency with other gems,
-* Test suite with 100%,
+* Test suite with 100% coverage,
 * Documentation: 100% coverage (according to YARD), green badge from inch.io
 * Algorithm works with different input token types (no limited to single character)
 
@@ -35,31 +36,33 @@ Notice that it is the same as the text 'abc' repeated three times. The Sequitur
 this repetition and will generate the two following rules:
 
 ```
-start : P1 P1 P1.  
+start : P1 P1 P1. 
 P1 : a b c.
 ```
 
 In plain English:  
--The first rule (named start) always represents the whole input. Here, it indicates that the input
-is three time the pattern encoded by the rule called P1.  
--The second rule (named P1) represents the sequence a b c.  
+-The first rule (named `start`) always represents the whole input. Here, it indicates that the input
+is three time the pattern encoded by the rule called `P1`.  
+-The second rule (named `P1`) represents the sequence `a b c`.  
 
 **Can you give another example?**  
 Yep. Assume this time that the input is *'ababcabcdabcde'*.
 Then Sequitur algorithm will generate the rule set:  
 ```
-start : P1 P2 P3 P3 e.  
-P1 : a b.  
-P2 : P1 c.  
-P3 : P2 d.   
+start : P1 P2 P3 P3 e. 
+P1 : a b. 
+P2 : P1 c. 
+P3 : P2 d.  
 ```
 
-Translated in plain English:  
-- Rule (start) tells that the input consists of the sequence of P1 P2 P3 patterns followed by the letter e.  
-- Rule (P1) represents the sequence 'ab'.  
-- Rule (P2) represents the pattern encoded by P1 (thus 'ab') then 'c'.   
-In other words, it represents the string 'abc'.  
-- Rule (P3) represents the pattern encoded by P2 then d. It is thus equivalent to 'abcd'.  
+Translated in plain English:
+
+- Rule (`start`) tells that the input consists of the sequence of `P1 P2 
+  P3` patterns followed by the letter `e`.  
+- Rule (`P1`) represents the sequence `ab`.  
+- Rule (`P2`) represents the pattern encoded by `P1` (thus `ab`) then `c`. In 
+  other words, it represents the string `abc`.  
+- Rule (`P3`) represents the pattern encoded by `P2` then `d`. It is thus equivalent to `abcd`.  
 
 **What is it used for?**  
 Sequitur can be used:  
@@ -75,13 +78,12 @@ repeated elements)
 The following Ruby snippet show how to apply Sequitur on the input string from the last example above.
 
 ```ruby  
+require 'sequitur'  # Load the Sequitur library
 
-    require 'sequitur'  # Load the Sequitur library
-
-    input_sequence =  'ababcabcdabcde'  # Let's analyze this string
+input_sequence =  'ababcabcdabcde'  # Let's analyze this string
 
-    # Run the Sequitur algorithm which will result in a grammar (=rule set)
-    grammar = Sequitur.build_from(input_sequence)
+# Run the Sequitur algorithm which will result in a grammar (=rule set)
+grammar = Sequitur.build_from(input_sequence)
 ````
 
 The demo illustrates how easy it is to run the algorithm on a string. However, the next question is how
@@ -93,27 +95,27 @@ Here's how:
 
 
 ```ruby  
-    require 'sequitur'
-    input_sequence =  'ababcabcdabcde'
-    grammar = Sequitur.build_from(input_sequence)
-
-    # To display the grammar rules on the console output
-    # We use a grammar formatter
-    formatter = Sequitur::Formatter::BaseText.new(STDOUT)
-
-    # Now render the rules. Each rule is displayed with the format:
-    # rule_id : a_sequence_grammar_symbols.
-    # Where:
-    # - rule_id is either 'start' or a name like 'Pxxxx' (xxxx is a sequential number)
-    # - a grammar symbol is either a terminal symbol
-    # (i.e. a character from the input) or a rule id
-    formatter.render(grammar.visitor)
-
-    # Rendered output is:
-    # start : P1 P2 P3 P3 e.
-    # P1 : a b.
-    # P2 : P1 c.
-    # P3 : P2 d.
+require 'sequitur'
+input_sequence =  'ababcabcdabcde'
+grammar = Sequitur.build_from(input_sequence)
+
+# To display the grammar rules on the console output
+# We use a grammar formatter
+formatter = Sequitur::Formatter::BaseText.new(STDOUT)
+
+# Now render the rules. Each rule is displayed with the format:
+# rule_id : a_sequence_grammar_symbols.
+# Where:
+# - rule_id is either 'start' or a name like 'Pxxxx' (xxxx is a sequential number)
+# - a grammar symbol is either a terminal symbol
+# (i.e. a character from the input) or a rule id
+formatter.render(grammar.visitor)
+
+# Rendered output is:
+# start : P1 P2 P3 P3 e.
+# P1 : a b.
+# P2 : P1 c.
+# P3 : P2 d.
 ```
 
 ## Understanding the algorithm's results
@@ -125,12 +127,12 @@ First of all, what is a **grammar**? To simplify the matter, one can see a gramm
 grammar rules. These rules are called production rules or more briefly **productions**.  
 
 In a context-free grammar, productions have the form:  
-````
+```
 P : body.
 ```
 
 Where:
-- The colon ':' character separates the head (= left-hand side) and the body (right-hand side, *rhs* in short)
+- The colon `':'` character separates the head (= left-hand side) and the body (right-hand side, *rhs* in short)
 of the rule.
 - The left-hand side consists just of one symbol, P. P is a categorized as a *nonterminal symbol* and for our purposes
 a nonterminal symbol can be seen as the "name" of the production. By contrast, a terminal symbol is just one element
@@ -148,10 +150,10 @@ Recall the above example: a single call to the `Sequitur#build_from` factory met
 suffices to construct a grammar object.
 
 ```ruby  
-    require 'sequitur'
+require 'sequitur'
 
-    input_sequence =  'ababcabcdabcde'
-    grammar = Sequitur.build_from(input_sequence)
+input_sequence =  'ababcabcdabcde'
+grammar = Sequitur.build_from(input_sequence)
 ```
 
 The return value `grammar` is a `Sequitur::SequiturGrammar` instance.
@@ -160,45 +162,44 @@ Unsurprisingly, the `Sequitur::SequiturGrammar` class defines an accessor method
 that returns the productions of the grammar as an array of `Sequitur::Production` objects.
 
 ```ruby
-	# Count the number of productions in the grammar
-	puts grammar.productions.size # => 4
+# Count the number of productions in the grammar
+puts grammar.productions.size # => 4
 
-	# Retrieve all productions of the grammar
-	all_prods = grammar.productions
+# Retrieve all productions of the grammar
+all_prods = grammar.productions
 
-	# Retrieve the start production
-	start_prod = grammar.production[0]
+# Retrieve the start production
+start_prod = grammar.production[0]
 ```
 
 Once we have a grip on a production, it is easy to access its right-hand side through the `Production#rhs` method.
 It returns an array of symbols.
 
 ```ruby
-	# ...Continuing the same example
-	# Retrieve the right-hand side of the production
-	prod_body = start_prod.rhs	# Return an Array object
+# ...Continuing the same example
+# Retrieve the right-hand side of the production
+prod_body = start_prod.rhs	# Return an Array object
 ```
 
 The RHS of a production is a sequence (i.e. Array) of symbols.
 How are the grammar symbols implemented?
--Terminal symbols are directly originating from the input sequence. They are inserted "as is" in the
-RHS. For instance, if the input sequence consists of integer values (i.e. Finum instances), then they
-will be inserted in the RHS of productions.
--Non-terminal symbols are implemented as `Sequitur::ProductionRef` objects.
+- Terminal symbols are directly originating from the input sequence. They are
+  inserted "as is" in the RHS. For instance, if the input sequence consists
+	of integer values (i.e. Integer instances), then they will be inserted in
+	the RHS of productions.
+- Non-terminal symbols are implemented as `Sequitur::ProductionRef` objects.
 
-A ProductionRef is reference to a Production object. The latter one can be accessed through the `ProductionRef#production` method.
+A ProductionRef is a reference to a Production object. The latter one can be accessed through the `ProductionRef#production` method.
 
 
 ### Installation ###
 The sequitur gem installation is fairly standard.  
 If your project has a `Gemfile` file, add `sequitur` to it. Otherwise, install the gem like this:
 
-```bash  
-$[sudo] gem install sequitur
+```sh  
+gem install sequitur
 ```
 
-
-
 ### Good to know ###
 The above examples might give the impression that the input stream must consist of single
 character tokens. This is simply not true.  

data/lib/sequitur/constants.rb

@@ -8,7 +8,7 @@ module Sequitur
   # rubocop:disable Naming/ConstantName
 
   # @return [String] The version number of the gem.
-  Version = '0.1.26'
+  Version = '0.1.27'
 
   # @return [String] Brief description of the gem.
   Description = 'Ruby implementation of the Sequitur algorithm'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sequitur
 version: !ruby/object:Gem::Version
-  version: 0.1.26
+  version: 0.1.27
 platform: ruby
 authors:
 - Dimitri Geshef
 bindir: bin
 cert_chain: []
-date: 2025-02-15 00:00:00.000000000 Z
+date: 2025-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -50,45 +50,45 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 3.10.0
 - !ruby/object:Gem::Dependency
-  name: rubygems
+  name: engtagger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: 0.4.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 0.4.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: 0.4.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
-  name: engtagger
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.9.3
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.9.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.9.3
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.9.3
 description: |
   Ruby implementation of the Sequitur algorithm. This algorithm automatically
   finds repetitions and hierarchical structures in a given sequence of input