qi 10.0.0.beta11 → 10.0.0.beta12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79ffab5e654d14cf9f3f7dac1c50bc5b5c612452d0fdea35a00d3529337fbff2
-  data.tar.gz: b8fecf9ff5dd97923070809b6a906c8b44cebbee9695ea242e314d53afb9fad8
+  metadata.gz: 7f3a609bb51c87ae5486c9244b948899f4e6ae46747ac80bf3be5f83ae76826a
+  data.tar.gz: 1843fa6cc35f2dcaaab08a7772abeb9f56fa3e7d0dc5dc69f9a742ec47e81169
 SHA512:
-  metadata.gz: cb36bd477ba3e756b116e3f2ab55bdb15ea50834461cc614865d8fdda56e271eff4675d998172bd766b8ca33e6944be3bbf567a1eba96b6215816234c485f6c9
-  data.tar.gz: e56b5f73bf2c0a1a3a256f813acfcf24af3bc3cdd570f2fb6ab1aa2f7ebc194ddd0b82e5ade5cbc052229377a8c768d3f49f45188d811a756ab7781481c69f08
+  metadata.gz: f79f7dc430f3e84b5cf816492c4f31c7776db329fffd18e161df929ccf18cb85b37cdd69e35c2b93da0e983e976d765bf69e8a33f1e946ec62d61c7b5583d164
+  data.tar.gz: '059b84b8c426af80188f0b6885ff921ab86f7015756d5309d75fd0ab621f1d93322be5f83f603a02535850645da432219af815871c480b56dec0e8f67db738bb'

data/README.md

@@ -6,14 +6,25 @@
 [![RuboCop](https://github.com/sashite/qi.rb/workflows/RuboCop/badge.svg?branch=main)](https://github.com/sashite/qi.rb/actions?query=workflow%3Arubocop+branch%3Amain)
 [![License](https://img.shields.io/github/license/sashite/qi.rb?label=License&logo=github)](https://github.com/sashite/qi.rb/raw/main/LICENSE.md)
 
-> `Qi` (Chinese: 棋; pinyin: _qí_) is an abstraction that could help to update positions for games like Shogi.
+Welcome to `Qi` (Chinese: 棋; pinyin: _qí_), a flexible and customizable library designed to represent and manipulate board game positions. `Qi` is ideal for a variety of board games, including chess, shogi, xiangqi, makruk, and more.
+
+With `Qi`, you can easily track the game state, including which pieces are on the board and where, as well as any captured pieces. The library allows for the application of game moves, updating the state of the game and generating a new position, all while preserving the original state.
+
+## Features:
+
+- **Flexible representation of game states:** `Qi`'s design allows it to adapt to different games with varying rules and pieces.
+- **Immutable positions:** Every move generates a new position, preserving the original one. This is particularly useful for scenarios like undoing moves or exploring potential future states in the game.
+- **Compact serialization:** `Qi` provides a compact string serialization method for game states, which is useful for saving game progress or transmitting game states over the network.
+- **Check state tracking:** In addition to the positions and captured pieces, `Qi` also allows tracking of specific game states such as check in chess.
+
+While `Qi` does not generate game moves itself, it serves as a solid foundation upon which game engines can be built. Its design is focused on providing a robust and adaptable representation of game states, paving the way for the development of diverse board game applications.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "qi", ">= 10.0.0.beta11"
+gem "qi", ">= 10.0.0.beta12"
 ```
 
 And then execute:
@@ -33,42 +44,42 @@ gem install qi --pre
 ```ruby
 require "qi"
 
-is_north_turn   = false
 north_captures  = %w[r r b g g g g s n n n n p p p p p p p p p p p p p p p p p]
 south_captures  = %w[S]
+captures        = north_captures + south_captures
 squares         = { 3 => "s", 4 => "k", 5 => "s", 22 => "+P", 43 => "+B" }
 
-qi0 = Qi.new(is_north_turn, north_captures, south_captures, squares)
+qi0 = Qi.new(*captures, **squares)
 
-qi0.north_captures  # => ["b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"]
-qi0.south_captures  # => ["S"]
-qi0.squares         # => {3=>"s", 4=>"k", 5=>"s", 22=>"+P", 43=>"+B"}
-qi0.north_turn?     # => false
-qi0.south_turn?     # => true
-qi0.serialize       # => "South-turn===b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s,S===3:s,4:k,5:s,22:+P,43:+B"
-qi0.inspect         # => "<Qi South-turn===b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s,S===3:s,4:k,5:s,22:+P,43:+B>"
+qi0.captures      # => ["S", "b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"]
+qi0.squares       # => {3=>"s", 4=>"k", 5=>"s", 22=>"+P", 43=>"+B"}
+qi0.in_check?     # => false
+qi0.not_in_check? # => true
+qi0.north_turn?   # => false
+qi0.south_turn?   # => true
+qi0.serialize     # => "{ S;b;g;g;g;g;n;n;n;n;p;p;p;p;p;p;p;p;p;p;p;p;p;p;p;p;p;r;r;s s@3;k@4;s@5;+P@22;+B@43 ."
+qi0.inspect       # => "<Qi { S;b;g;g;g;g;n;n;n;n;p;p;p;p;p;p;p;p;p;p;p;p;p;p;p;p;p;r;r;s s@3;k@4;s@5;+P@22;+B@43 .>"
 qi0.to_a
 # [false,
-#  ["b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"],
-#  ["S"],
+#  ["S", "b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"],
 #  {3=>"s", 4=>"k", 5=>"s", 22=>"+P", 43=>"+B"},
-#  {}]
-
-qi1 = qi0.commit(43, 13, "+B", nil)
-
-qi1.north_captures  # => ["b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"]
-qi1.south_captures  # => ["S"]
-qi1.squares         # => {3=>"s", 4=>"k", 5=>"s", 22=>"+P", 13=>"+B"}
-qi1.north_turn?     # => true
-qi1.south_turn?     # => false
-qi1.serialize       # => "North-turn===b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s,S===3:s,4:k,5:s,13:+B,22:+P"
-qi1.inspect         # => "<Qi North-turn===b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s,S===3:s,4:k,5:s,13:+B,22:+P>"
+#  false]
+
+qi1 = qi0.commit(is_in_check: true, 43 => nil, 13 => "+B")
+
+qi1.captures      # => ["S", "b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"]
+qi1.squares       # => {3=>"s", 4=>"k", 5=>"s", 22=>"+P", 13=>"+B"}
+qi1.in_check?     # => true
+qi1.not_in_check? # => false
+qi1.north_turn?   # => true
+qi1.south_turn?   # => false
+qi1.serialize     # => "} S;b;g;g;g;g;n;n;n;n;p;p;p;p;p;p;p;p;p;p;p;p;p;p;p;p;p;r;r;s s@3;k@4;s@5;+B@13;+P@22 +"
+qi1.inspect       # => "<Qi } S;b;g;g;g;g;n;n;n;n;p;p;p;p;p;p;p;p;p;p;p;p;p;p;p;p;p;r;r;s s@3;k@4;s@5;+B@13;+P@22 +>"
 qi1.to_a
 # [true,
-#  ["b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"],
-#  ["S"],
+#  ["S", "b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"],
 #  {3=>"s", 4=>"k", 5=>"s", 22=>"+P", 13=>"+B"},
-#  {}]
+#  true]
 ```
 
 ## License

data/lib/qi.rb

@@ -1,269 +1,132 @@
 # frozen_string_literal: true
 
 require "digest"
-require_relative "qi/error/drop"
+require "kernel/boolean"
 
-# Qi is a class for representing a state of games like Shogi. It includes
-# information about the current turn, captures, game board, and other game options.
+# The Qi class represents a state of games such as Shogi.
 class Qi
-  # Constants for representing the North and South players.
-  North = :North
-  South = :South
+  # @return [Array] the pieces captured by the current player.
+  attr_reader :captures
 
-  # @return [Array] the pieces captured by the north player
-  attr_reader :north_captures
-
-  # @return [Array] the pieces captured by the south player
-  attr_reader :south_captures
-
-  # @return [Hash] the current state of the game board
+  # @return [Hash] the current state of the board.
   attr_reader :squares
 
-  # @return [Hash] additional game options
-  attr_reader :options
-
-  # Initialize a new Qi object.
-  #
-  # @example Creating a new Qi object
-  #   qi = Qi.new(true, ['P', 'G'], ['B', '+B'], {56 => 'P', 3 => 'g', 64 => '+B'}, fullmove_number: 42, is_in_check: false)
-  #
-  # @param [Boolean] is_north_turn true if it's the north player's turn, false otherwise
-  # @param [Array] north_captures the pieces captured by the north player
-  # @param [Array] south_captures the pieces captured by the south player
-  # @param [Hash] squares the current state of the game board
-  # @param [Hash] options additional game options
-  def initialize(is_north_turn, north_captures, south_captures, squares, **options)
-    @is_north_turn  = is_north_turn
-    @north_captures = north_captures.sort
-    @south_captures = south_captures.sort
+  # Initializes a new game state.
+  #
+  # @param capture [String, nil] the piece to be captured.
+  # @param captures [Array] the pieces already captured.
+  # @param drop [String, nil] the piece to be dropped.
+  # @param is_in_check [Boolean] whether the current player is in check.
+  # @param is_north_turn [Boolean] whether it's North's turn.
+  # @param squares [Hash] the current state of the board.
+  def initialize(capture = nil, *captures, drop: nil, is_in_check: false, is_north_turn: false, **squares)
+    captures << capture                       unless capture.nil?
+    captures.delete_at(captures.rindex(drop)) unless drop.nil?
+
+    @captures       = captures.sort
+    @is_in_check    = Boolean(is_in_check)
+    @is_north_turn  = Boolean(is_north_turn)
     @squares        = squares.compact
-    @options        = options
   end
 
-  # Apply a move or a drop on the board.
-  #
-  # The method creates a new instance of Qi representing the state of the game after the move.
-  # This includes updating the captures and the positions of the pieces on the board.
-  #
-  # @param src_square [Object, nil] the source square, or nil if dropping a piece from hand
-  # @param dst_square [Object] the destination square
-  # @param piece_name [String] the name of the piece to move
-  # @param in_hand [String, nil] the piece in hand, or nil if moving a piece from a square
-  # @param options [Hash] options to pass to the new instance
-  #
-  # @example Applying a move
-  #   qi = Qi.new(true, ['P', 'B'], ['G', '+B'], {56 => 'P', 64 => '+B'})
-  #   qi.commit(56, 47, 'P', nil) #=> <Qi South-turn===B,P,+B,G===47:P,64:+B>
-  #
-  # @example Applying a capture
-  #   qi = Qi.new(true, ['P', 'B'], ['G', '+B'], {56 => 'P', 64 => '+B'})
-  #   qi.commit(56, 47, 'P', 'G') #=> <Qi South-turn===B,G,P,+B,G===47:P,64:+B>
+  # Commits a move and returns a new game state.
   #
-  # @example Applying a drop
-  #   qi = Qi.new(true, ['P', 'B', 'G'], ['G', '+B'], {56 => 'P', 64 => '+B'})
-  #   qi.commit(nil, 47, 'G', 'G') #=> <Qi South-turn===B,P,+B,G===47:G,56:P,64:+B>
-  #
-  # @return [Qi] the new game state after the move
-  def commit(src_square, dst_square, piece_name, in_hand, **options)
-    raise ::ArgumentError, "Both src_square and in_hand cannot be nil" if src_square.nil? && in_hand.nil?
-
-    modified_captures = update_captures(src_square, in_hand)
-    modified_squares = squares.merge({ src_square => nil, dst_square => piece_name })
-    self.class.new(south_turn?, *modified_captures, modified_squares, **options)
+  # @param capture [String, nil] the piece to be captured.
+  # @param drop [String, nil] the piece to be dropped.
+  # @param is_in_check [Boolean] whether the current player is in check.
+  # @param diffs [Hash] the differences in the state of the board.
+  # @return [Qi] the new game state.
+  def commit(capture: nil, drop: nil, is_in_check: false, **diffs)
+    self.class.new(capture, *captures, drop:, is_in_check:, is_north_turn: south_turn?, **squares.merge(diffs))
   end
 
-  # Compare this Qi object with another for equality.
-  #
-  # @example Comparing two Qi objects
-  #   qi1 = Qi.new(...)
-  #   qi2 = Qi.new(...)
-  #   qi1.eql?(qi2) #=> true or false
-  #
-  # @param [Qi] other the other Qi object to compare with
-  # @return [Boolean] true if the two objects represent the same game state, false otherwise
-  def eql?(other)
-    return false unless other.respond_to?(:serialize)
-
-    other.serialize == serialize
-  end
-  alias == eql?
-
-  # Get the captures of the current player.
-  #
-  # The method returns the north player's captures when it's their turn,
-  # and the south player's captures when it's their turn.
-  #
-  # @example When it's the north player's turn
-  #   qi = Qi.new(true, ['P', 'B'], ['G', '+B'], {56 => 'P', 64 => '+B'})
-  #   qi.current_captures #=> ['B', 'P']
-  #
-  # @example When it's the south player's turn
-  #   qi = Qi.new(false, ['P', 'B'], ['G', '+B'], {56 => 'P', 64 => '+B'})
-  #   qi.current_captures #=> ['+B', 'G']
-  #
-  # @return [Array] the captures of the current player
-  def current_captures
-    north_turn? ? north_captures : south_captures
-  end
-
-  # Get the captures of the opponent player.
-  #
-  # @return [Array] the captures of the opponent player
-  def opponent_captures
-    north_turn? ? south_captures : north_captures
-  end
-
-  # Get the current turn.
-  #
-  # @return [Symbol] :North if it's the north player's turn, :South otherwise
-  def current_turn
-    north_turn? ? North : South
+  # @return [Boolean] whether the current player is in check.
+  def in_check?
+    @is_in_check
   end
 
-  # Get the next turn.
-  #
-  # @return [Symbol] :South if it's the north player's turn, :North otherwise
-  def next_turn
-    north_turn? ? South : North
+  # @return [Boolean] whether the current player is not in check.
+  def not_in_check?
+    !in_check?
   end
 
-  # Check if it's the north player's turn.
-  #
-  # @return [Boolean] true if it's the north player's turn, false otherwise
+  # @return [Boolean] whether it's North's turn.
   def north_turn?
     @is_north_turn
   end
 
-  # Check if it's the south player's turn.
-  #
-  # @return [Boolean] true if it's the south player's turn, false otherwise
+  # @return [Boolean] whether it's South's turn.
   def south_turn?
     !north_turn?
   end
 
-  # Convert the state to an array.
-  #
-  # @example Converting the state to an array
-  #   qi.to_a #=> [true, ['P', 'G'], ['B', '+B'], {56 => 'P', 3 => 'g', 64 => '+B'}, {}]
-  #
-  # @return [Array] an array representing the game state
+  # @return [Boolean] whether the other game state is equal to this one.
+  def eql?(other)
+    return false unless other.respond_to?(:serialize)
+
+    other.serialize == serialize
+  end
+  alias == eql?
+
+  # @return [Array] the array representation of the game state.
   def to_a
     [
       north_turn?,
-      north_captures,
-      south_captures,
+      captures,
       squares,
-      options
+      in_check?
     ]
   end
 
-  # Convert the state to a hash.
-  #
-  # @example Converting the state to a hash
-  #   qi.to_h #=> {is_north_turn: true, north_captures: ['P', 'G'], south_captures: ['B', '+B'], squares: {56 => 'P', 3 => 'g', 64 => '+B'}, options: {}}
-  #
-  # @return [Hash] a hash representing the game state
+  # @return [Hash] the hash representation of the game state.
   def to_h
     {
-      is_north_turn:  north_turn?,
-      north_captures:,
-      south_captures:,
+      is_north_turn: north_turn?,
+      captures:,
       squares:,
-      options:
+      is_in_check:   in_check?
     }
   end
 
-  # Generate a hash value for the game state.
-  #
-  # @example Generating a hash value
-  #   qi.hash #=> "10dfb778f6559dd368c510a27e3b00bdb5b4ad88d4d67f38864d7e36de7c2f9c"
-  #
-  # @return [String] a SHA256 hash of the serialized game state
+  # @return [String] the SHA-256 hash of the serialized game state.
   def hash
     ::Digest::SHA256.hexdigest(serialize)
   end
 
-  # Serialize the game state.
-  #
-  # @example Serializing the game state
-  #   qi.serialize #=> "North-turn===P,G,B,+B===3:g,56:P,64:+B"
-  #
-  # @return [String] a string representation of the game state
+  # @return [String] the string representation of the game state.
   def serialize
-    serialized_turn     = "#{current_turn}-turn"
-    serialized_captures = (north_captures + south_captures).join(",")
-    serialized_squares  = squares.keys.sort.map { |i| "#{i}:#{squares.fetch(i)}" }.join(",")
-
-    "#{serialized_turn}===#{serialized_captures}===#{serialized_squares}"
+    [
+      serialized_turn,
+      serialized_captures,
+      serialized_squares,
+      serialized_in_check
+    ].join(" ")
   end
 
-  # Provide a string representation of the game state for debugging.
-  #
-  # @example Getting a string representation of the game state
-  #   qi.inspect #=> "<Qi North-turn===P,G,B,+B===3:g,56:P,64:+B>"
-  #
-  # @return [String] a string representation of the game state
+  # @return [String] the string representation of the object.
   def inspect
     "<#{self.class} #{serialize}>"
   end
 
   private
 
-  # Update captures based on the source square and the piece in hand.
-  #
-  # If the source square is not nil and in_hand is nil (i.e., we're moving a piece on the board),
-  # the captures remain the same. If the source square is not nil and in_hand is not nil
-  # (i.e., we're capturing a piece that will remain in hand), the piece is added to the
-  # current player's captures. If the source square is nil (i.e., we're dropping a piece from hand),
-  # the piece is removed from the current player's captures.
-  #
-  # @param src_square [Object, nil] the source square, or nil if dropping a piece from hand
-  # @param in_hand [String, nil] the piece in hand, or nil if moving a piece from a square
-  #
-  # @example When moving a piece on the board
-  #   qi = Qi.new(true, ['P', 'B'], ['G', '+B'], {56 => 'P', 64 => '+B'})
-  #   qi.send(:update_captures, 56, nil) #=> [['B', 'P'], ['G', '+B']]
-  #
-  # @example When capturing a piece that will remain in hand
-  #   qi = Qi.new(true, ['P', 'B'], ['G', '+B'], {56 => 'P', 64 => '+B'})
-  #   qi.send(:update_captures, 56, 'G') #=> [['B', 'P', 'G'], ['G', '+B']]
-  #
-  # @example When dropping a piece from hand
-  #   qi = Qi.new(true, ['P', 'B', 'G'], ['G', '+B'], {56 => 'P', 64 => '+B'})
-  #   qi.send(:update_captures, nil, 'G') #=> [['B', 'P'], ['G', '+B']]
-  #
-  # @return [Array] a two-element array with the updated north and south captures
-  def update_captures(src_square, in_hand)
-    return [north_captures, south_captures] if in_hand.nil?
-
-    captures = if src_square.nil?
-                 remove_from_captures(in_hand, *current_captures)
-               else
-                 current_captures + [in_hand]
-               end
+  # @return [String] the serialized turn.
+  def serialized_turn
+    north_turn? ? "}" : "{"
+  end
 
-    north_turn? ? [captures, opponent_captures] : [opponent_captures, captures]
+  # @return [String] the serialized captures.
+  def serialized_captures
+    captures.join(";")
   end
 
-  # Removes a piece from the captures.
-  #
-  # If the piece is not found in the captures, an Error::Drop exception is raised.
-  #
-  # @param piece [String] the piece to remove from the captures
-  # @param captures [Array] the captures to update
-  #
-  # @example
-  #   qi = Qi.new(true, ['P', 'B', 'G'], ['G', '+B'], {56 => 'P', 64 => '+B'})
-  #   qi.send(:remove_from_captures, 'G', *qi.current_captures) #=> ['P', 'B']
-  #
-  # @raise [Error::Drop] if the piece is not found in the captures
-  #
-  # @return [Array] the captures after removing the piece
-  def remove_from_captures(piece, *captures)
-    index = captures.rindex(piece)
-    raise Error::Drop, "There are no #{piece} in hand" if index.nil?
+  # @return [String] the serialized board state.
+  def serialized_squares
+    squares.keys.sort.map { |i| "#{squares.fetch(i)}@#{i}" }.join(";")
+  end
 
-    captures.delete_at(index)
-    captures
+  # @return [String] the serialized check state.
+  def serialized_in_check
+    in_check? ? "+" : "."
   end
 end

metadata

@@ -1,16 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: qi
 version: !ruby/object:Gem::Version
-  version: 10.0.0.beta11
+  version: 10.0.0.beta12
 platform: ruby
 authors:
 - Cyril Kato
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-12 00:00:00.000000000 Z
-dependencies: []
-description: An abstraction that could help to update positions for games like Shogi.
+date: 2023-05-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kernel-boolean
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A flexible and customizable library for representing and manipulating
+  game states, ideal for developing board games like chess, shogi, or xiangqi.
 email: contact@cyril.email
 executables: []
 extensions: []
@@ -19,7 +34,6 @@ files:
 - LICENSE.md
 - README.md
 - lib/qi.rb
-- lib/qi/error/drop.rb
 homepage: https://github.com/sashite/qi.rb
 licenses:
 - MIT
@@ -43,5 +57,5 @@ requirements: []
 rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
-summary: An abstraction that could help to update positions for games like Shogi.
+summary: Versatile Board Game Position Representation
 test_files: []

data/lib/qi/error/drop.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-class Qi
-  # The Error module contains custom error classes for the Qi game.
-  module Error
-    # The Drop class is a custom error class that inherits from IndexError.
-    # It is raised when a drop operation in the game of Qi is invalid.
-    #
-    # @see IndexError
-    class Drop < ::IndexError
-    end
-  end
-end