oppen 0.1.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3566ebc351b729f845e192fb3687bfae4a874879b3741de2e1c43fb97946aa23
-  data.tar.gz: 9499a00567a1ad0d7f7ffc551573888513eb952945a83d90022a499d31248828
+  metadata.gz: 7a496d964de133aa177270080b9444d8e9ef865ce1b355bef4a6c4a43462d48c
+  data.tar.gz: d2955b0983ef133fd374c1c46fc3424d9cff05c4ec910a6ca5ad94ec3f2db78d
 SHA512:
-  metadata.gz: 0f1348d6dac1afc87a495f2e395ed63a28ae42a722c235f1fe33fc317f1e13b0cbe5d7cae51c67a446755a7f26382c9b7555b80e394e9bdc161e620c2fbfde44
-  data.tar.gz: 430164e1995f18e4c75cddd59e6e39f6669c9312d01d29cb9670298b3459fb345ccd1a22742728b951859c248e628e0b1b968968ad00f025ea070173816fb476
+  metadata.gz: d4319e6b5be2d8fa394cf8d6cd593c4e8ab0b5c1c0a313cc42e287a93b46e23a95d844b8bddd01e5547ac67faa4b04395d5edb5ae911380572a0df1b7acf0c95
+  data.tar.gz: 680e57e6f38f4cda980b57d04e787b4b33becc7b45de4c73810b243e82169411d62cd0d34b56a67df3e96debcc6d8a2ad777046aedec342429792fc91f3b3346

data/README.md

@@ -1,30 +1,74 @@
 # Oppen's Pretty Printer
 [![CI badge]][CI]
 [![Docs latest badge]][Docs latest]
-<!-- [![rubygems.org badge]][rubygems.org] -->
+[![rubygems.org badge]][rubygems.org]
 
 [CI badge]: https://github.com/Faveod/oppen-ruby/actions/workflows/test.yml/badge.svg
 [CI]: https://github.com/Faveod/oppen-ruby/actions/workflows/test.yml
 [Docs latest badge]: https://github.com/Faveod/oppen-ruby/actions/workflows/docs.yml/badge.svg
 [Docs latest]: https://faveod.github.io/oppen-ruby/
+[rubygems.org badge]: https://img.shields.io/gem/v/oppen?label=rubygems.org
+[rubygems.org]: https://rubygems.org/gems/oppen
 
 An implementation of the pretty printing algorithm described by
 [Derek C. Oppen](https://dl.acm.org/doi/pdf/10.1145/357114.357115).
 
-> [!WARNING]
+We also provide an API similar to
+[`ruby/prettyprint`](https://github.com/ruby/prettyprint), which we call
+`Wadler`, in reference to Philip Wadler's paper, [_A prettier
+printer_](https://homepages.inf.ed.ac.uk/wadler/papers/prettier/prettier.pdf),
+the basis for `prettyprint`. This can be really helpful if you decide to
+transition from `ruby/prettyprint` to this gem.
+
+`Wadler` is implemented on top of `Oppen`, and it provides more options than
+`ruby/prettyprint`, notably:
+1. Consistent and inconsistent breaking.
+1. Explicit breaking, which is achievable in `ruby/prettyprint` with some
+monkeypatching.
+
+> [!CAUTION]
 > This is still under development.
 
-## Difference with the original algorithm
+## Usage
+
+> [!WARNING]
+> Lands when the APIs are stable.
+
+## Oppen vs Wadler
+
+`Wadler` calls `Oppen` under the hood, so it's not a separate implementation,
+and it's not calling ruby's `prettyprint`.
+
+Both implementations have their use cases:
+1. Oppen gives more control over tokens sent to the printer.
+1. Wadler gives a more _"functional"_ API, which is far nicer to work with.
+
+That being said, both APIs in this gem can achieve the same results, especially
+on consistent and inconsistent breaking.
+
+## Noteworthy details
+
+### Difference with Oppen's original algorithm
+
+1. We took liberty to rename functions to make the API more modern and closer to
+what we expect when writing Ruby code.  All correspondences with the algorithm
+as described in Oppen's paper are noted in the comments of classes and methods.
+1. We do not raise exceptions when we overflow the margin. The only exceptions
+that we raise indicate a bug in the implementation. Please report them.
+
+### Difference with `ruby/prettyprint`
 
-We decided to diverge from Oppen's original algorithm to provide a more
-idiomatic Ruby experience, in one particular aspect: exceptions/errors: we do
-not raise exceptions when we overflow the margin.
+Oppen's algorithm and `ruby/prettyprint` do not have the same starting positions
+for a group's indentation. That's why you need to pay particular attention to
+calls for `nest`; you might want to decrease them by `1` if you care about keeping
+the same behavior.
 
-The only exceptions that we raise indicate a bug in the implementation. Please
-report them.
+This is what we do in our test suite to verify the correspondence of the `Wadler`
+API and the `ruby/prettyprint`. We decided to shift the burden to the user because
+we think that the deicision taken by `ruby/prettyprint` does not suit us.
 
 ## Related projects
 
-1. [Python implementation](https://github.com/stevej2608/oppen-pretty-printer)
-as a library.
-1. [rustc implementation](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast_pretty/pp/index.html)
+1. [`ruby/prettyprint`](https://github.com/ruby/prettyprint)
+1. [rustc implementation](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast_pretty/pp/index.html)
+1. [`stevej2608/oppen-pretty-printer`](https://github.com/stevej2608/oppen-pretty-printer) as a library.

data/lib/oppen/print_stack.rb

@@ -21,6 +21,12 @@ module Oppen
     # IO element that builds the output.
     attr_reader :buffer
 
+    # Config containing customization flags
+    attr_reader :config
+
+    # Callable that generate spaces
+    attr_reader :genspace
+
     # Array representing the stack of PrintStackEntries.
     attr_reader :items
 
@@ -35,8 +41,18 @@ module Oppen
     # @return [Integer] Current available space (Called index in the original paper).
     attr_reader :space
 
-    def initialize(margin, new_line)
-      @buffer = StringIO.new
+    def initialize(margin, new_line, config, space, out)
+      @buffer = out
+      @config = config
+      @genspace =
+        if space.respond_to?(:call)
+          raise ArgumentError, 'space argument must be a Proc of arity 1' \
+            if space.to_proc.arity != 1
+
+          space
+        else
+          ->(n) { space * n }
+        end
       @items = []
       @new_line = new_line
       @margin = margin
@@ -45,7 +61,7 @@ module Oppen
 
     # Returns the output of the print stack
     #
-    # @return [StringIO]
+    # @return [String]
     def output
       buffer.string
     end
@@ -87,7 +103,15 @@ module Oppen
           else
             Token::BreakType::INCONSISTENT
           end
-        push PrintStackEntry.new space - token.offset, type
+        if config&.indent_anchor == Config::IndentAnchor::ON_BEGIN
+          indent = token.offset
+          if !items.empty?
+            indent += top.offset
+          end
+        else
+          indent = space - token.offset
+        end
+        push PrintStackEntry.new indent, type
       else
         push PrintStackEntry.new 0, Token::BreakType::FITS
       end
@@ -114,18 +138,32 @@ module Oppen
       block = top
       case block.break_type
       in Token::BreakType::FITS
-        @space -= token.blank_space
-        indent token.blank_space
+        @space -= token.length
+        write token
       in Token::BreakType::CONSISTENT
         @space = block.offset - token.offset
-        print_new_line margin - space
+        indent =
+          if config&.indent_anchor == Config::IndentAnchor::ON_BEGIN
+            token.offset
+          else
+            margin - space
+          end
+        write token.line_continuation
+        print_new_line indent
       in Token::BreakType::INCONSISTENT
         if token_length > space
           @space = block.offset - token.offset
-          print_new_line margin - space
+          indent =
+            if config&.indent_anchor == Config::IndentAnchor::ON_BEGIN
+              token.offset
+            else
+              margin - space
+            end
+          write token.line_continuation
+          print_new_line indent
         else
-          @space -= token.blank_space
-          indent token.blank_space
+          @space -= token.length
+          write token
         end
       end
     end
@@ -140,7 +178,7 @@ module Oppen
     # @see Token::String
     def handle_string(token, token_length)
       @space = [0, space - token_length].max
-      write token.value
+      write token
     end
 
     # Push a PrintStackEntry into the stack.
@@ -183,16 +221,21 @@ module Oppen
     # @return [Nil]
     def print_new_line(amount)
       write new_line
-      indent amount
+      if config&.indent_anchor == Config::IndentAnchor::ON_BEGIN
+        @space = margin - top.offset - amount
+        indent margin - space
+      else
+        indent amount
+      end
     end
 
     # Write a string to the output.
     #
-    # @param string [String]
+    # @param obj [Object]
     #
     # @return [Nil]
-    def write(string)
-      buffer.write(string)
+    def write(obj)
+      buffer.write(obj.to_s)
     end
 
     # Add indentation by `amount`.
@@ -203,7 +246,7 @@ module Oppen
     #
     # @return [Nil]
     def indent(amount)
-      write ' ' * amount
+      write genspace.call(amount)
     end
   end
 end

data/lib/oppen/printer.rb

@@ -9,6 +9,7 @@ require_relative 'print_stack'
 module Oppen
   # Oppen pretty-printer.
   class Printer
+    attr_reader :config
     # Ring buffer left index.
     #
     # @note Called left as well in the original paper.
@@ -51,13 +52,23 @@ module Oppen
     #
     # @param margin   [Integer] maximum line width desired.
     # @param new_line [String]  the delimiter between lines.
-    def initialize(margin, new_line)
+    # @param config [Config]
+    # @param space [String, Proc] could be a String or a callable.
+    #   If it's a string, spaces will be generated with the the
+    #   lambda `->(n){ n * space }`, where `n` is the number of columns
+    #   to indent.
+    #   If it's a callable, it will receive `n` and it needs to return
+    #   a string.
+    # @param out [Object] should have a write and string method
+    def initialize(margin, new_line, config = Config.oppen,
+                   space = ' ', out = StringIO.new)
       # Maximum size if the stacks
       n = 3 * margin
 
+      @config = config
       @left = 0
       @left_total = 1
-      @print_stack = PrintStack.new margin, new_line
+      @print_stack = PrintStack.new margin, new_line, config, space, out
       @right = 0
       @right_total = 1
       @scan_stack = ScanStack.new n
@@ -65,7 +76,7 @@ module Oppen
       @tokens = Array.new n
     end
 
-    # @return [StringIO]
+    # @return [String]
     def output
       print_stack.output
     end
@@ -137,6 +148,11 @@ module Oppen
         tokens[right] = token
         size[right] = -1
         scan_stack.push right
+        if config&.eager_print &&
+           (!scan_stack.empty? && right_total - left_total < print_stack.space)
+          check_stack 0
+          advance_left tokens[left], size[left]
+        end
       end
     end
 
@@ -158,7 +174,7 @@ module Oppen
       scan_stack.push right
       tokens[right] = token
       size[right] = -right_total
-      @right_total += token.blank_space
+      @right_total += token.length
     end
 
     # Handle String Token.
@@ -220,7 +236,7 @@ module Oppen
 
       case token
       when Token::Break
-        @left_total += token.blank_space
+        @left_total += token.length
       when Token::String
         @left_total += token_length
       end
@@ -239,7 +255,7 @@ module Oppen
     # @param depth [Integer] depth of the group
     #
     # @return [Nil]
-    def check_stack(depth) # rubocop:disable Metrics/AbcSize
+    def check_stack(depth)
       return if scan_stack.empty?
 
       x = scan_stack.top

data/lib/oppen/token.rb

@@ -3,7 +3,7 @@
 # Oppen.
 module Oppen
   # Token.
-  module Token
+  class Token
     # BreakType.
     #
     # FITS => No break is needed (the block fits on the line).
@@ -18,43 +18,79 @@ module Oppen
       CONSISTENT = 2
     end
 
+    # Default token length
+    # @return [Integer]
+    def length
+      0
+    end
+
     # String Token.
-    class String
+    class String < Token
       # @return [String] String value.
       attr_reader :value
 
       def initialize(value)
         @value = value
+        super()
       end
 
       # @return [Integer]
       def length
         value.length
       end
+
+      # @return [String]
+      def to_s
+        value
+      end
     end
 
     # Break Token.
-    class Break
-      # @return [Integer] Number of blank spaces.
-      attr_reader :blank_space
+    class Break < Token
+      # @return [String] Break strings.
+      attr_reader :str
+      # @return [String] If a new line is needed display this string before the new line
+      attr_reader :line_continuation
       # @return [Integer] Indentation.
       attr_reader :offset
 
-      def initialize(blank_space: 1, offset: 0)
-        @blank_space = blank_space
+      def initialize(str = ' ', line_continuation: '', offset: 0)
+        raise ArgumentError, 'line_continuation cannot be nil' if line_continuation.nil?
+
+        @line_continuation = line_continuation
         @offset = offset
+        @str = str
+        super()
+      end
+
+      # @return [Integer]
+      def length
+        str.length
+      end
+
+      # @return [String]
+      def to_s
+        str
       end
     end
 
     # Distinguished instance of Break which forces a line break.
     class LineBreak < Break
-      def initialize(offset: 0)
-        super(blank_space: 9999, offset:)
+      # Mock string that represents an infinite string to force new line.
+      class LineBreakString
+        # @return [Integer]
+        def length
+          999_999
+        end
+      end
+
+      def initialize(line_continuation: '', offset: 0)
+        super(LineBreakString.new, line_continuation:, offset:)
       end
     end
 
     # Begin Token.
-    class Begin
+    class Begin < Token
       # @return [BreakType]
       attr_reader :break_type
       # @return [Integer] Indentation.
@@ -63,16 +99,17 @@ module Oppen
       def initialize(break_type: BreakType::INCONSISTENT, offset: 2)
         @offset = offset
         @break_type = break_type
+        super()
       end
     end
 
     # End Token
-    class End
+    class End < Token
       nil
     end
 
     # EOF Token
-    class EOF
+    class EOF < Token
       nil
     end
   end

data/lib/oppen/version.rb

@@ -5,5 +5,5 @@ module Oppen
   # Oppen version
   #
   # @return [String] current version
-  VERSION = '0.1.0' # managed by release.sh
+  VERSION = '0.9.0' # managed by release.sh
 end

data/lib/oppen.rb

@@ -5,21 +5,142 @@ require_relative 'oppen/print_stack'
 require_relative 'oppen/scan_stack'
 require_relative 'oppen/token'
 require_relative 'oppen/version'
+require_relative 'wadler/print'
 
 # Oppen.
 module Oppen
   # Entry point of the pretty printer.
   #
-  # @param tokens [Array[Token]] the list of tokens to be printed
+  # @param config [Config]
+  # @param space [String, Proc] could be a String or a callable.
+  #   If it's a string, spaces will be generated with the the
+  #   lambda `->(n){ n * space }`, where `n` is the number of columns
+  #   to indent.
+  #   If it's a callable, it will receive `n` and it needs to return
+  #   a string.
   # @param margin [Integer] maximum line width desired
   # @param new_line [String] the delimiter between lines
+  # @param out [Object] should have a write and string method
+  # @param tokens [Array[Token]] the list of tokens to be printed
   #
-  # @return [StringIO] output of the pretty printer
-  def self.print(tokens: [], margin: 80, new_line: "\n")
-    printer = Printer.new margin, new_line
+  # @return [String] output of the pretty printer
+  def self.print(config: Config.oppen, space: ' ',
+                 margin: 80, new_line: "\n", out: StringIO.new, tokens: [])
+    printer = Printer.new margin, new_line, config, space, out
     tokens.each do |token|
       printer.print token
     end
     printer.output
   end
+
+  # Config.
+  class Config
+    # IndentAnchor.
+    #
+    # ON_BREAK => anchor on break position (as in Oppen's original paper)
+    # ON_BEGIN => anchor on begin block position
+    module IndentAnchor
+      # @return [Integer]
+      ON_BREAK = 0
+      # @return [Integer]
+      ON_BEGIN = 1
+    end
+
+    attr_accessor :indent_anchor
+    # Print groups eagerly
+    #
+    # @example
+    #  out = Oppen::Wadler.new (margin: 13)
+    #  out.group {
+    #    out.group {
+    #      out.text 'abc'
+    #      out.breakable
+    #      out.text 'def'
+    #    }
+    #    out.group {
+    #      out.text 'ghi'
+    #      out.breakable
+    #      out.text 'jkl'
+    #    }
+    #  }
+    #  out.output
+    #
+    #  # eager_print: false
+    #  # =>
+    #  # abc
+    #  # defghi jkl
+    #  #
+    #  # eager_print: true
+    #  # =>
+    #  # abc defghi
+    #  # jkl
+    #
+    # @return [Boolean]
+    attr_accessor :eager_print
+
+    def initialize(indent_anchor: IndentAnchor::ON_BREAK, eager_print: false)
+      @indent_anchor = indent_anchor
+      @eager_print = eager_print
+    end
+
+    # Default config for Oppen usage
+    # @return [Config]
+    def self.oppen
+      new
+    end
+
+    # Default config for Wadler usage
+    # @return [Config]
+    def self.wadler(eager_print: true)
+      new(indent_anchor: IndentAnchor::ON_BEGIN, eager_print:)
+    end
+  end
+
+  # @param value [String]
+  #
+  # @return [Oppen::Token::String] a new String token
+  def self.string(value)
+    Token::String.new(value)
+  end
+
+  # @param str [String]
+  # @param line_continuation [String] If a new line is needed display this string before the new line
+  # @param offset [Integer]
+  #
+  # @return [Oppen::Token::Break] a new Break token
+  def self.break(str = ' ', line_continuation: '', offset: 0)
+    Token::Break.new(str, line_continuation:, offset:)
+  end
+
+  # @param line_continuation [String] If a new line is needed display this string before the new line
+  # @param offset [Integer]
+  #
+  # @return [Oppen::Token::LineBreak] a new LineBreak token
+  def self.line_break(line_continuation: '', offset: 0)
+    Token::LineBreak.new(line_continuation:, offset:)
+  end
+
+  # @param offset [Integer]
+  #
+  # @return [Oppen::Token::Begin] a new consistent Begin token
+  def self.begin_consistent(offset: 2)
+    Token::Begin.new(break_type: Token::BreakType::CONSISTENT, offset:)
+  end
+
+  # @param offset [Integer]
+  #
+  # @return [Oppen::Token::Begin] a new inconsistent Begin token
+  def self.begin_inconsistent(offset: 2)
+    Token::Begin.new(break_type: Token::BreakType::INCONSISTENT, offset:)
+  end
+
+  # @return [Oppen::Token::End] a new End token
+  def self.end
+    Token::End.new
+  end
+
+  # @return [Oppen::Token::EOF] a new EOF token
+  def self.eof
+    Token::EOF.new
+  end
 end

data/lib/wadler/print.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+# Oppen.
+module Oppen
+  # Wadler.
+  class Wadler
+    attr_reader :config
+    attr_reader :current_indent
+    attr_reader :space
+    attr_reader :margin
+    attr_reader :new_line
+    attr_reader :out
+    attr_reader :tokens
+
+    # @param config [Oppen::Config]
+    # @param space [String, Proc] could be a String or a callable.
+    #   If it's a string, spaces will be generated with the the
+    #   lambda `->(n){ n * space }`, where `n` is the number of columns
+    #   to indent.
+    #   If it's a callable, it will receive `n` and it needs to return
+    #   a string.
+    # @param margin [Integer]
+    # @param new_line [String]
+    # @param out [Object] should have a write and string method
+    def initialize(config: Config.wadler, space: ' ',
+                   margin: 80, new_line: "\n", out: StringIO.new)
+      @config = config
+      @current_indent = 0
+      @space = space
+      @margin = margin
+      @new_line = new_line
+      @out = out
+      @tokens = []
+    end
+
+    # @return [String]
+    def output
+      if !tokens.last.is_a? Oppen::Token::EOF
+        tokens << Oppen.eof
+      end
+      Oppen.print(tokens:, margin:, new_line:, config:, space:, out:)
+    end
+
+    # @param indent [Integer] group indentation
+    # @param open_obj [String] group opening delimiter
+    # @param close_obj [String] group closing delimiter
+    # @param break_type [Oppen::Token::BreakType] group breaking type
+    #
+    # @yield the block of text in a group
+    #
+    # @return [Nil]
+    def group(indent = 0, open_obj = '', close_obj = '',
+              break_type = Oppen::Token::BreakType::CONSISTENT)
+      raise ArgumentError, "#{open_obj.nil? ? 'open_obj' : 'close_obj'} cannot be nil" \
+        if open_obj.nil? || close_obj.nil?
+
+      tokens <<
+        case break_type
+        in Oppen::Token::BreakType::CONSISTENT
+          Oppen.begin_consistent(offset: indent)
+        in Oppen::Token::BreakType::INCONSISTENT
+          Oppen.begin_inconsistent(offset: indent)
+        end
+
+      if !open_obj.empty?
+        self.break
+        text(open_obj)
+      end
+
+      yield
+
+      if !close_obj.empty?
+        self.break
+        text(close_obj)
+      end
+
+      tokens << Oppen.end
+    end
+
+    # @param indent [Integer] nest indentation
+    # @param open_obj [String] nest opening delimiter
+    # @param close_obj [String] nest closing delimiter
+    # @param break_type [Oppen::Token::BreakType] nest breaking type
+    #
+    # @return [Nil]
+    def nest(indent, open_obj = '', close_obj = '',
+             break_type = Oppen::Token::BreakType::CONSISTENT)
+      raise ArgumentError, "#{open_obj.nil? ? 'open_obj' : 'close_obj'} cannot be nil" \
+        if open_obj.nil? || close_obj.nil?
+
+      @current_indent += indent
+
+      if !open_obj.empty?
+        text(open_obj)
+        self.break
+      end
+
+      begin
+        yield
+      ensure
+        @current_indent -= indent
+      end
+
+      return if close_obj.empty?
+
+      self.break
+      text(close_obj)
+    end
+
+    # @param value [String]
+    #
+    # @return [Nil]
+    def text(value)
+      tokens << Oppen.string(value)
+    end
+
+    # @param str [String]
+    # @param line_continuation [String] If a new line is needed display this string before the new line
+    #
+    # @return [Nil]
+    def breakable(str = ' ', line_continuation: '')
+      tokens << Oppen.break(str, line_continuation:, offset: current_indent)
+    end
+
+    # @param line_continuation [String] If a new line is needed display this string before the new line
+    #
+    # @return [Nil]
+    def break(line_continuation: '')
+      tokens << Oppen.line_break(line_continuation:, offset: current_indent)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oppen
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Amine Mike El Maalouf <amine.el-maalouf@epita.fr>
@@ -9,25 +9,23 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-09-13 00:00:00.000000000 Z
+date: 2024-09-27 00:00:00.000000000 Z
 dependencies: []
 description: Implementation of the Oppen's pretty printing algorithm
 email: 
-executables:
-- main.rb
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
-- bin/main.rb
-- bin/repl.rb
 - lib/oppen.rb
 - lib/oppen/print_stack.rb
 - lib/oppen/printer.rb
 - lib/oppen/scan_stack.rb
 - lib/oppen/token.rb
 - lib/oppen/version.rb
+- lib/wadler/print.rb
 homepage: http://github.com/Faveod/oppen-ruby
 licenses:
 - MIT

data/bin/main.rb

@@ -1,24 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) if !$LOAD_PATH.include?(lib)
-
-require 'oppen'
-
-list = [
-  Oppen::Token::Begin.new,
-  Oppen::Token::String.new('XXXXXXXXXX'),
-  Oppen::Token::Break.new,
-  Oppen::Token::String.new('+'),
-  Oppen::Token::Break.new,
-  Oppen::Token::String.new('YYYYYYYYYY'),
-  Oppen::Token::Break.new,
-  Oppen::Token::String.new('+'),
-  Oppen::Token::Break.new,
-  Oppen::Token::String.new('ZZZZZZZZZZ'),
-  Oppen::Token::End.new,
-  Oppen::Token::EOF.new,
-]
-
-puts Oppen.print tokens: list, line_width: 25

data/bin/repl.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'colored'
-
-# Fancy
-WELCOME = <<-'YGM'
-   __ __   ___   __ __  ____    ____    ___  ___ ___  ____    ____  ___ ___    ___
-  |  |  | /   \ |  |  ||    \  /    |  /  _]|   |   ||    \  /    ||   |   |  /  _]
-  |  |  ||     ||  |  ||  D  )|   __| /  [_ | _   _ ||  _  ||  o  || _   _ | /  [_
-  |  ~  ||  O  ||  |  ||    / |  |  ||    _]|  \_/  ||  |  ||     ||  \_/  ||    _]
-  |___, ||     ||  :  ||    \ |  |_ ||   [_ |   |   ||  |  ||  _  ||   |   ||   [_
-  |     ||     ||     ||  .  \|     ______     ______     ______   __      ||     |
-  |____/  \___/  \__,_||__|\_||___ /\  == \   /\  ___\   /\  == \ /\ \  ___||_____|
-                                   \ \  __<   \ \  __\   \ \  _-/ \ \ \____
-                                    \ \_\ \_\  \ \_____\  \ \_\    \ \_____\
-                                     \/_/ /_/   \/_____/   \/_/     \/_____/
-YGM
-
-puts WELCOME.green