oppen 0.1.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3566ebc351b729f845e192fb3687bfae4a874879b3741de2e1c43fb97946aa23
-  data.tar.gz: 9499a00567a1ad0d7f7ffc551573888513eb952945a83d90022a499d31248828
+  metadata.gz: 81c1832fc106f4f4622738ad55ea231c66bdb40a96523d9913b3426781aed296
+  data.tar.gz: 9c5797979a36d529317bf31cdc85a158309c26f5a0c298f8cd1e577a83f4386a
 SHA512:
-  metadata.gz: 0f1348d6dac1afc87a495f2e395ed63a28ae42a722c235f1fe33fc317f1e13b0cbe5d7cae51c67a446755a7f26382c9b7555b80e394e9bdc161e620c2fbfde44
-  data.tar.gz: 430164e1995f18e4c75cddd59e6e39f6669c9312d01d29cb9670298b3459fb345ccd1a22742728b951859c248e628e0b1b968968ad00f025ea070173816fb476
+  metadata.gz: e6a37e27b916fc83323a4b4b387c3990265094ac0c326b5770328ce8d43977b421c8cc0b2092b3c8a877d619ee56578abee1c0f5b2af9390c12f696211eb6446
+  data.tar.gz: 2548a7c7cd71299b8779714537916cf603f72a57bf2d02cf0ebcad163bafe7d53299e833cae07ada8a8cc30ddf2ba4e7ef19df6556656c2c920a90478c734ce4

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,31 +21,47 @@ 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
 
     # Delimiter between lines in output
     attr_reader :new_line
 
-    # Page margin (Called length in the original paper).
-    attr_reader :margin
+    # Maximum allowed width for printing (Called length in the original paper).
+    attr_reader :width
 
     # Current available space (Called index in the original paper).
     #
     # @return [Integer] Current available space (Called index in the original paper).
     attr_reader :space
 
-    def initialize(margin, new_line)
-      @buffer = StringIO.new
+    def initialize(width, 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
-      @space = margin
+      @width = width
+      @space = width
     end
 
     # Returns the output of the print stack
     #
-    # @return [StringIO]
+    # @return [String]
     def output
       buffer.string
     end
@@ -55,39 +71,47 @@ module Oppen
     # @note Called Print in the original paper.
     #
     # @param token [Token]
-    # @param token_length [Integer]
+    # @param token_width [Integer]
     #
     # @return [Nil]
-    def print(token, token_length)
+    def print(token, token_width)
       case token
       in Token::Begin
-        handle_begin token, token_length
+        handle_begin token, token_width
       in Token::End
         handle_end
       in Token::Break
-        handle_break token, token_length
+        handle_break token, token_width
       in Token::String
-        handle_string token, token_length
+        handle_string token, token_width
       end
     end
 
     # Handle Begin Token.
     #
     # @param token [Token]
-    # @param token_length [Integer]
+    # @param token_width [Integer]
     #
     # @return [Nil]
     #
     # @see Token::Begin
-    def handle_begin(token, token_length)
-      if token_length > space
+    def handle_begin(token, token_width)
+      if token_width > space
         type =
           if token.break_type == Token::BreakType::CONSISTENT
             Token::BreakType::CONSISTENT
           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
@@ -105,27 +129,41 @@ module Oppen
     # Handle Break Token.
     #
     # @param token [Token]
-    # @param token_length [Integer]
+    # @param token_width [Integer]
     #
     # @return [Nil]
     #
     # @see Token::Break
-    def handle_break(token, token_length)
+    def handle_break(token, token_width)
       block = top
       case block.break_type
       in Token::BreakType::FITS
-        @space -= token.blank_space
-        indent token.blank_space
+        @space -= token.width
+        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
+            width - space
+          end
+        write token.line_continuation
+        print_new_line indent
       in Token::BreakType::INCONSISTENT
-        if token_length > space
+        if token_width > space
           @space = block.offset - token.offset
-          print_new_line margin - space
+          indent =
+            if config&.indent_anchor == Config::IndentAnchor::ON_BEGIN
+              token.offset
+            else
+              width - space
+            end
+          write token.line_continuation
+          print_new_line indent
         else
-          @space -= token.blank_space
-          indent token.blank_space
+          @space -= token.width
+          write token
         end
       end
     end
@@ -133,14 +171,14 @@ module Oppen
     # Handle String Token.
     #
     # @param token [Token]
-    # @param token_length [Integer]
+    # @param token_width [Integer]
     #
     # @return [Nil]
     #
     # @see Token::String
-    def handle_string(token, token_length)
-      @space = [0, space - token_length].max
-      write token.value
+    def handle_string(token, token_width)
+      @space = [0, space - token_width].max
+      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 = width - top.offset - amount
+        indent width - 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

@@ -4,11 +4,13 @@ require 'stringio'
 
 require_relative 'scan_stack'
 require_relative 'print_stack'
+require_relative 'utils'
 
 # Oppen.
 module Oppen
   # Oppen pretty-printer.
   class Printer
+    attr_reader :config
     # Ring buffer left index.
     #
     # @note Called left as well in the original paper.
@@ -47,25 +49,44 @@ module Oppen
     # @note Called token in the original paper.
     attr_reader :tokens
 
-    # @note Called PrettyPrintInit in the original paper.
+    # Some description
     #
-    # @param margin   [Integer] maximum line width desired.
+    # @example
+    #   "This is a string" # => and this is a comment
+    #   out = Oppen::Wadler.new (margin: 13) # Hawn
+    #   # Baliz
+    #
+    # @example
+    #   "This is a string" # => and this is a comment
+    #   # var = 12
+    #
+    # @param width [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(width, new_line, config = Config.oppen,
+                   space = ' ', out = StringIO.new)
       # Maximum size if the stacks
-      n = 3 * margin
+      n = 3 * width
 
+      @config = config
       @left = 0
       @left_total = 1
-      @print_stack = PrintStack.new margin, new_line
+      @print_stack = PrintStack.new width, new_line, config, space, out
       @right = 0
       @right_total = 1
-      @scan_stack = ScanStack.new n
+      @scan_stack = ScanStack.new n, config
       @size = Array.new n
       @tokens = Array.new n
     end
 
-    # @return [StringIO]
+    # @return [String]
     def output
       print_stack.output
     end
@@ -137,6 +158,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 +184,7 @@ module Oppen
       scan_stack.push right
       tokens[right] = token
       size[right] = -right_total
-      @right_total += token.blank_space
+      @right_total += token.width
     end
 
     # Handle String Token.
@@ -168,12 +194,12 @@ module Oppen
     # @see Token::String
     def handle_string(token)
       if scan_stack.empty?
-        print_stack.print token, token.length
+        print_stack.print token, token.width
       else
         advance_right
         tokens[right] = token
-        size[right] = token.length
-        @right_total += token.length
+        size[right] = token.width
+        @right_total += token.width
         check_stream
       end
     end
@@ -204,7 +230,10 @@ module Oppen
       @right = (right + 1) % scan_stack.length
       return if right != left
 
-      raise 'Token queue full'
+      raise 'Token queue full' if !config.upsize_stack?
+
+      @size, = Utils.upsize_circular_array(@size, @left)
+      @tokens, @left, @right = Utils.upsize_circular_array(@tokens, @left)
     end
 
     # Advances the `left` pointer and lets the print stack
@@ -213,16 +242,16 @@ module Oppen
     # @note Called AdvanceLeft as well in the original paper.
     #
     # @return [Nil]
-    def advance_left(token, token_length)
-      return if token_length.negative?
+    def advance_left(token, token_width)
+      return if token_width.negative?
 
-      print_stack.print token, token_length
+      print_stack.print token, token_width
 
       case token
       when Token::Break
-        @left_total += token.blank_space
+        @left_total += token.width
       when Token::String
-        @left_total += token_length
+        @left_total += token_width
       end
 
       return if left == right
@@ -239,7 +268,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/scan_stack.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
+require_relative 'utils'
+
 # Oppen.
 module Oppen
   # A fixed-size stack that can be popped from top and bottom.
   class ScanStack
-    def initialize(size)
+    def initialize(size, config)
       @bottom = 0
+      @config = config
       @empty = true
       @stack = Array.new(size)
       @top = 0
@@ -68,7 +71,9 @@ module Oppen
       else
         @top = increment(@top)
         if @top == @bottom
-          raise 'Stack full'
+          raise 'Stack full' if !@config.upsize_stack?
+
+          @stack, @bottom, @top = Utils.upsize_circular_array(@stack, @bottom)
         end
       end
       @stack[@top] = value

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,67 @@ module Oppen
       CONSISTENT = 2
     end
 
+    # Default token width
+    # @return [Integer]
+    def width = 0
+
     # String Token.
-    class String
+    class String < Token
       # @return [String] String value.
       attr_reader :value
+      # @return [Integer]
+      attr_reader :width
 
-      def initialize(value)
+      def initialize(value, width: value.length)
         @value = value
+        @width = width
+        super()
       end
 
-      # @return [Integer]
-      def length
-        value.length
-      end
+      # @return [String]
+      def to_s = value
     end
 
     # Break Token.
-    class Break
-      # @return [Integer] Number of blank spaces.
-      attr_reader :blank_space
+    class Break < Token
+      # @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
+      # @return [String] Break strings.
+      attr_reader :str
+      # @return [Integer]
+      attr_reader :width
 
-      def initialize(blank_space: 1, offset: 0)
-        @blank_space = blank_space
+      def initialize(str = ' ', width: str.length, line_continuation: '', offset: 0)
+        raise ArgumentError, 'line_continuation cannot be nil' if line_continuation.nil?
+
+        @line_continuation = line_continuation
         @offset = offset
+        @str = str
+        @width = width
+        super()
       end
+
+      # @return [String]
+      def to_s = str
     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
+
+      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 +87,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/utils.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Oppen.
+module Oppen
+  # Utils.
+  module Utils
+    # Rotates circular array and triples its size.
+    # @param arr [Array]
+    # @param offset [Integer] Rotation amount
+    #
+    # @return [Array(Array, Integer, Integer)] upsized array, lhs, rhs
+    def self.upsize_circular_array(arr, offset)
+      size = arr.size
+      arr = arr.rotate(offset)
+      arr.fill(nil, size, 2 * size)
+      [arr, 0, size]
+    end
+  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.1' # managed by release.sh
 end

data/lib/oppen.rb

@@ -5,21 +5,148 @@ 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 margin [Integer] maximum line width desired
+  # @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 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
+  # @param width [Integer] maximum line width desired
   #
-  # @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: ' ',
+                 new_line: "\n", out: StringIO.new, tokens: [], width: 80)
+    printer = Printer.new width, 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
+
+    def initialize(indent_anchor: IndentAnchor::ON_BREAK, eager_print: false, upsize_stack: false)
+      @indent_anchor = indent_anchor
+      @eager_print = eager_print
+      @upsize_stack = upsize_stack
+    end
+
+    # Print groups eagerly
+    #
+    # @example
+    #  out = Oppen::Wadler.new (width: 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]
+    def eager_print? = @eager_print
+
+    def upsize_stack? = @upsize_stack
+
+    # 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, upsize_stack: true)
+      new(indent_anchor: IndentAnchor::ON_BEGIN, eager_print:, upsize_stack:)
+    end
+  end
+
+  # @param value [String]
+  # @param width [Integer] token width that defaults to value.length
+  #
+  # @return [Oppen::Token::String] a new String token
+  def self.string(value, width: value.length)
+    Token::String.new(value, width:)
+  end
+
+  # @param str [String]
+  # @param line_continuation [String] If a new line is needed display this string before the new line
+  # @param offset [Integer]
+  # @param width [Integer] token width that defaults to str.length
+  #
+  # @return [Oppen::Token::Break] a new Break token
+  def self.break(str = ' ', line_continuation: '', offset: 0, width: str.length)
+    Token::Break.new(str, width:, 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 :new_line
+    attr_reader :out
+    attr_reader :tokens
+    attr_reader :width
+
+    # @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 new_line [String]
+    # @param out [Object] should have a write and string method
+    # @param width [Integer]
+    def initialize(config: Config.wadler, space: ' ',
+                   new_line: "\n", out: StringIO.new, width: 80)
+      @config = config
+      @current_indent = 0
+      @space = space
+      @width = width
+      @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:, new_line:, config:, space:, out:, width:)
+    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, width: value.length)
+      tokens << Oppen.string(value, width:)
+    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 = ' ', width: str.length, line_continuation: '')
+      tokens << Oppen.break(str, width:, 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.1
 platform: ruby
 authors:
 - Amine Mike El Maalouf <amine.el-maalouf@epita.fr>
@@ -9,25 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-09-13 00:00:00.000000000 Z
+date: 2024-10-22 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/utils.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