twisty_puzzles 0.0.1 → 0.0.2

data/lib/twisty_puzzles/cube_constants.rb

@@ -3,51 +3,50 @@
 require 'twisty_puzzles/utils/array_helper'
 
 module TwistyPuzzles
-  
-    # Various constants about the cube.
-    module CubeConstants
-      include Utils::ArrayHelper
-
-      # The order determines the priority of the faces.
-      FACE_SYMBOLS = %i[U F R L B D].freeze
-      OPPOSITE_FACE_SYMBOLS = [%i[U D], %i[F B], %i[R L]].freeze
-      raise unless FACE_SYMBOLS.sort == OPPOSITE_FACE_SYMBOLS.flatten.sort
-
-      FACE_NAMES = FACE_SYMBOLS.map(&:to_s).freeze
-      ALPHABET_SIZE = 24
-      # Stickers on each Skewb face.
-      SKEWB_STICKERS = 5
-      CHIRALITY_FACE_SYMBOLS = %i[U R F].freeze
-
-      def opposite_face_symbol(face_symbol)
-        candidates = OPPOSITE_FACE_SYMBOLS.select { |ss| ss.include?(face_symbol) }
-        raise if candidates.length > 1
-        raise ArgumentError, "Invalid face symbol #{face_symbol}." if candidates.empty?
-
-        only(only(candidates).reject { |s| s == face_symbol })
-      end
+  # Various constants about the cube.
+  module CubeConstants
+    include Utils::ArrayHelper
+
+    # The order determines the priority of the faces.
+    FACE_SYMBOLS = %i[U F R L B D].freeze
+    OPPOSITE_FACE_SYMBOLS = [%i[U D], %i[F B], %i[R L]].freeze
+    raise unless FACE_SYMBOLS.sort == OPPOSITE_FACE_SYMBOLS.flatten.sort
+
+    FACE_NAMES = FACE_SYMBOLS.map(&:to_s).freeze
+    ALPHABET_SIZE = 24
+    # Stickers on each Skewb face.
+    SKEWB_STICKERS = 5
+    CHIRALITY_FACE_SYMBOLS = %i[U R F].freeze
+
+    def opposite_face_symbol(face_symbol)
+      candidates = OPPOSITE_FACE_SYMBOLS.select { |ss| ss.include?(face_symbol) }
+      raise if candidates.length > 1
+      raise ArgumentError, "Invalid face symbol #{face_symbol}." if candidates.empty?
+
+      only(only(candidates).reject { |s| s == face_symbol })
+    end
 
-      def chirality_canonical_face_symbol(face_symbol)
-        if CHIRALITY_FACE_SYMBOLS.include?(face_symbol)
-          face_symbol
-        else
-          opposite_face_symbol(face_symbol)
-        end
+    def chirality_canonical_face_symbol(face_symbol)
+      if CHIRALITY_FACE_SYMBOLS.include?(face_symbol)
+        face_symbol
+      else
+        opposite_face_symbol(face_symbol)
       end
+    end
 
-      def valid_chirality?(face_symbols)
-        # To make it comparable to our CHIRALITY_FACE_SYMBOLS, we switch each face used in c
-        # different from the ones used in the CHIRALITY_FACE_SYMBOLS for the opposite face.
-        canonical_face_symbols = face_symbols.map { |f| chirality_canonical_face_symbol(f) }
+    def valid_chirality?(face_symbols)
+      # To make it comparable to our CHIRALITY_FACE_SYMBOLS, we switch each face used in c
+      # different from the ones used in the CHIRALITY_FACE_SYMBOLS for the opposite face.
+      canonical_face_symbols = face_symbols.map { |f| chirality_canonical_face_symbol(f) }
 
-        # Each time we swap a face for the opposite, the chirality direction should be inverted.
-        no_swapped_face_symbols = canonical_face_symbols.zip(face_symbols).count { |a, b| a != b }
-        inverted = no_swapped_face_symbols.odd?
-        inverted_face_symbols = inverted ? canonical_face_symbols.reverse : canonical_face_symbols
+      # Each time we swap a face for the opposite, the chirality direction should be inverted.
+      no_swapped_face_symbols = canonical_face_symbols.zip(face_symbols).count { |a, b| a != b }
+      inverted = no_swapped_face_symbols.odd?
+      inverted_face_symbols = inverted ? canonical_face_symbols.reverse : canonical_face_symbols
 
-        # If the corner is not equal modulo rotation to CHIRALITY_FACE_SYMBOLS after this
-        # transformation, the original corner had a bad chirality.
-        turned_equals?(inverted_face_symbols, CHIRALITY_FACE_SYMBOLS)
-      end
+      # If the corner is not equal modulo rotation to CHIRALITY_FACE_SYMBOLS after this
+      # transformation, the original corner had a bad chirality.
+      turned_equals?(inverted_face_symbols, CHIRALITY_FACE_SYMBOLS)
     end
+  end
 end

data/lib/twisty_puzzles/cube_direction.rb

@@ -3,25 +3,22 @@
 require 'twisty_puzzles/abstract_direction'
 
 module TwistyPuzzles
-  
-    # Represents the direction of a cube move or rotation.
-    class CubeDirection < AbstractDirection
-      NUM_DIRECTIONS = 4
-      NON_ZERO_DIRECTIONS = (1...NUM_DIRECTIONS).map { |d| new(d) }.freeze
-      ALL_DIRECTIONS = Array.new(NUM_DIRECTIONS) { |d| new(d) }.freeze
-      ZERO = new(0)
-      FORWARD = new(1)
-      DOUBLE = new(2)
-      BACKWARD = new(3)
+  # Represents the direction of a cube move or rotation.
+  class CubeDirection < AbstractDirection
+    NUM_DIRECTIONS = 4
+    NON_ZERO_DIRECTIONS = (1...NUM_DIRECTIONS).map { |d| new(d) }.freeze
+    ALL_DIRECTIONS = Array.new(NUM_DIRECTIONS) { |d| new(d) }.freeze
+    ZERO = new(0)
+    FORWARD = new(1)
+    DOUBLE = new(2)
+    BACKWARD = new(3)
 
-      def name
-        SIMPLE_DIRECTION_NAMES[@value]
-      end
+    def name
+      SIMPLE_DIRECTION_NAMES[@value]
+    end
 
-      def double_move?
-        @value == 2
-      end
+    def double_move?
+      @value == 2
     end
+  end
 end
-
-

data/lib/twisty_puzzles/cube_move.rb

@@ -6,379 +6,378 @@ require 'twisty_puzzles/algorithm'
 require 'twisty_puzzles/puzzle'
 
 module TwistyPuzzles
-  
-    # Helper class to print various types of M slice moves.
-    module MSlicePrintHelper
-      def to_s
-        use_face = AbstractMove::SLICE_NAMES.key?(@axis_face)
-        axis_face = use_face ? @axis_face : @axis_face.opposite
-        direction = use_face ? @direction : @direction.inverse
-        slice_name = AbstractMove::SLICE_NAMES[axis_face]
-        "#{slice_name}#{direction.name}"
-      end
+  # Helper class to print various types of M slice moves.
+  module MSlicePrintHelper
+    def to_s
+      use_face = AbstractMove::SLICE_NAMES.key?(@axis_face)
+      axis_face = use_face ? @axis_face : @axis_face.opposite
+      direction = use_face ? @direction : @direction.inverse
+      slice_name = AbstractMove::SLICE_NAMES[axis_face]
+      "#{slice_name}#{direction.name}"
     end
+  end
 
-    # Base class for cube moves.
-    class CubeMove < AxisFaceAndDirectionMove
-      def puzzles
-        [Puzzle::NXN_CUBE]
-      end
+  # Base class for cube moves.
+  class CubeMove < AxisFaceAndDirectionMove
+    def puzzles
+      [Puzzle::NXN_CUBE]
     end
+  end
 
-    # A fat M slice move that moves everything but the outer layers.
-    class FatMSliceMove < CubeMove
-      include MSlicePrintHelper
-
-      def prepend_rotation(_other, _cube_size)
-        nil
-      end
+  # A fat M slice move that moves everything but the outer layers.
+  class FatMSliceMove < CubeMove
+    include MSlicePrintHelper
 
-      def prepend_fat_m_slice_move(other, _cube_size)
-        return unless same_axis?(other)
+    def prepend_rotation(_other, _cube_size)
+      nil
+    end
 
-        other_direction = other.translated_direction(@axis_face)
-        Algorithm.move(FatMSliceMove.new(@axis_face, @direction + other_direction))
-      end
+    def prepend_fat_m_slice_move(other, _cube_size)
+      return unless same_axis?(other)
 
-      def prepend_fat_move(other, cube_size)
-        # Note that changing the order is safe because that method returns nil if no cancellation
-        # can be performed.
-        other.prepend_fat_m_slice_move(self, cube_size)
-      end
+      other_direction = other.translated_direction(@axis_face)
+      Algorithm.move(FatMSliceMove.new(@axis_face, @direction + other_direction))
+    end
 
-      def prepend_slice_move(_other, _cube_size)
-        nil
-      end
+    def prepend_fat_move(other, cube_size)
+      # Note that changing the order is safe because that method returns nil if no cancellation
+      # can be performed.
+      other.prepend_fat_m_slice_move(self, cube_size)
+    end
 
-      def slice_move?
-        true
-      end
+    def prepend_slice_move(_other, _cube_size)
+      nil
+    end
 
-      def equivalent_internal?(other, cube_size)
-        case other
-        when SliceMove
-          return equivalent_slice_move?(other, cube_size)
-        when FatMSliceMove
-          return @axis_face == other.axis_face.opposite && @direction == other.direction.inverse
-        end
+    def slice_move?
+      true
+    end
 
-        false
+    def equivalent_internal?(other, cube_size)
+      case other
+      when SliceMove
+        return equivalent_slice_move?(other, cube_size)
+      when FatMSliceMove
+        return @axis_face == other.axis_face.opposite && @direction == other.direction.inverse
       end
 
-      protected
+      false
+    end
 
-      def equivalent_slice_move?(other, cube_size)
-        cube_size == 3 && other.slice_index == 1 &&
-          (@axis_face == other.axis_face && @direction == other.direction ||
-           @axis_face == other.axis_face.opposite && @direction == other.direction.inverse)
-      end
+    protected
+
+    def equivalent_slice_move?(other, cube_size)
+      cube_size == 3 && other.slice_index == 1 &&
+        (@axis_face == other.axis_face && @direction == other.direction ||
+         @axis_face == other.axis_face.opposite && @direction == other.direction.inverse)
     end
+  end
 
-    # An M slice move for which we don't know yet whether it's an inner or fat M slice move.
-    class MaybeFatMSliceMaybeInnerMSliceMove < CubeMove
-      include MSlicePrintHelper
+  # An M slice move for which we don't know yet whether it's an inner or fat M slice move.
+  class MaybeFatMSliceMaybeInnerMSliceMove < CubeMove
+    include MSlicePrintHelper
 
-      # For even layered cubes, m slice moves are meant as very fat moves where only the outer
-      # layers stay.
-      # For odd layered cubes, we only move the very middle.
-      def decide_meaning(cube_size)
-        if cube_size.even?
-          FatMSliceMove.new(@axis_face, @direction)
-        else
-          InnerMSliceMove.new(@axis_face, @direction, cube_size / 2)
-        end
+    # For even layered cubes, m slice moves are meant as very fat moves where only the outer
+    # layers stay.
+    # For odd layered cubes, we only move the very middle.
+    def decide_meaning(cube_size)
+      if cube_size.even?
+        FatMSliceMove.new(@axis_face, @direction)
+      else
+        InnerMSliceMove.new(@axis_face, @direction, cube_size / 2)
       end
     end
+  end
 
-    # A fat move with a width. For width 1, this becomes a normal outer move.
-    class FatMove < CubeMove
-      def initialize(axis_face, direction, width = 1)
-        super(axis_face, direction)
-        raise TypeError unless width.is_a?(Integer)
-        raise ArgumentError, "Invalid width #{width} for fat move." unless width >= 1
+  # A fat move with a width. For width 1, this becomes a normal outer move.
+  class FatMove < CubeMove
+    def initialize(axis_face, direction, width = 1)
+      super(axis_face, direction)
+      raise TypeError unless width.is_a?(Integer)
+      raise ArgumentError, "Invalid width #{width} for fat move." unless width >= 1
 
-        @width = width
-      end
+      @width = width
+    end
 
-      OUTER_MOVES = Face::ELEMENTS.product(CubeDirection::NON_ZERO_DIRECTIONS).map do |f, d|
-        FatMove.new(f, d)
-      end.freeze
+    OUTER_MOVES = Face::ELEMENTS.product(CubeDirection::NON_ZERO_DIRECTIONS).map do |f, d|
+      FatMove.new(f, d)
+    end.freeze
 
-      attr_reader :width
+    attr_reader :width
 
-      def identifying_fields
-        super + [@width]
-      end
+    def identifying_fields
+      super + [@width]
+    end
 
-      def to_s
-        "#{@width > 2 ? @width : ''}#{@axis_face.name}#{@width > 1 ? 'w' : ''}#{@direction.name}"
-      end
+    def to_s
+      "#{@width > 2 ? @width : ''}#{@axis_face.name}#{@width > 1 ? 'w' : ''}#{@direction.name}"
+    end
 
-      def slice_move?
-        false
-      end
+    def slice_move?
+      false
+    end
 
-      def with_width(width)
-        FatMove.new(@axis_face, @direction, width)
-      end
+    def with_width(width)
+      FatMove.new(@axis_face, @direction, width)
+    end
 
-      def inverted_width(cube_size)
-        cube_size - @width
-      end
+    def inverted_width(cube_size)
+      cube_size - @width
+    end
 
-      def prepend_rotation(other, cube_size)
-        # Note that changing the order is safe because that method returns nil if no cancellation
-        # can be performed.
-        other.prepend_fat_move(self, cube_size)
-      end
+    def prepend_rotation(other, cube_size)
+      # Note that changing the order is safe because that method returns nil if no cancellation
+      # can be performed.
+      other.prepend_fat_move(self, cube_size)
+    end
 
-      def prepend_fat_m_slice_move(other, cube_size)
-        if adjacent_mslice_move?(other)
-          Algorithm.move(FatMove.new(@axis_face, @direction, cube_size - 1))
-        elsif contained_mslice_move?(other, cube_size)
-          Algorithm.move(FatMove.new(@axis_face, @direction, 1))
-        end
+    def prepend_fat_m_slice_move(other, cube_size)
+      if adjacent_mslice_move?(other)
+        Algorithm.move(FatMove.new(@axis_face, @direction, cube_size - 1))
+      elsif contained_mslice_move?(other, cube_size)
+        Algorithm.move(FatMove.new(@axis_face, @direction, 1))
       end
+    end
 
-      # rubocop:disable Metrics/PerceivedComplexity
-      # rubocop:disable Metrics/CyclomaticComplexity
-      def prepend_fat_move(other, cube_size)
-        if same_fat_block?(other)
-          merge_with_same_fat_block(other)
-        elsif opposite_fat_block?(other, cube_size)
-          merge_with_opposite_fat_block(other)
-        elsif leaves_inner_slice_move?(other)
-          Algorithm.move(inner_slice_move)
-        elsif other.leaves_inner_slice_move?(self)
-          Algorithm.move(other.inner_slice_move)
-        elsif leaves_inner_fat_mslice_move?(other, cube_size)
-          Algorithm.move(inner_fat_mslice_move(cube_size))
-        elsif other.leaves_inner_fat_mslice_move?(self, cube_size)
-          Algorithm.move(other.inner_fat_mslice_move(cube_size))
-        end
-      end
-      # rubocop:enable Metrics/CyclomaticComplexity
-      # rubocop:enable Metrics/PerceivedComplexity
-
-      def prepend_slice_move(other, cube_size)
-        return unless same_axis?(other)
-
-        translated_direction = other.translated_direction(@axis_face)
-        translated_slice_index = other.translated_slice_index(@axis_face, cube_size)
-        move =
-          case translated_slice_index
-          when @width
-            return unless translated_direction == @direction
-
-            with_width(@width + 1)
-          when @width - 1
-            return unless translated_direction == @direction.inverse
-
-            with_width(@width - 1)
-          else
-            return
-          end
-        Algorithm.move(move)
+    # rubocop:disable Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def prepend_fat_move(other, cube_size)
+      if same_fat_block?(other)
+        merge_with_same_fat_block(other)
+      elsif opposite_fat_block?(other, cube_size)
+        merge_with_opposite_fat_block(other)
+      elsif leaves_inner_slice_move?(other)
+        Algorithm.move(inner_slice_move)
+      elsif other.leaves_inner_slice_move?(self)
+        Algorithm.move(other.inner_slice_move)
+      elsif leaves_inner_fat_mslice_move?(other, cube_size)
+        Algorithm.move(inner_fat_mslice_move(cube_size))
+      elsif other.leaves_inner_fat_mslice_move?(self, cube_size)
+        Algorithm.move(other.inner_fat_mslice_move(cube_size))
       end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
 
-      protected
+    def prepend_slice_move(other, cube_size)
+      return unless same_axis?(other)
 
-      def merge_with_same_fat_block(other)
-        Algorithm.move(FatMove.new(@axis_face, @direction + other.direction, @width))
-      end
+      translated_direction = other.translated_direction(@axis_face)
+      translated_slice_index = other.translated_slice_index(@axis_face, cube_size)
+      move =
+        case translated_slice_index
+        when @width
+          return unless translated_direction == @direction
 
-      def merge_with_opposite_fat_block(other)
-        rotation = Rotation.new(@axis_face, @direction)
-        move = FatMove.new(other.axis_face, other.direction + @direction, other.width)
-        Algorithm.new([move, rotation])
-      end
+          with_width(@width + 1)
+        when @width - 1
+          return unless translated_direction == @direction.inverse
 
-      # The outermost slice move inside this fat move.
-      def inner_slice_move
-        raise ArgumentError unless @width >= 2
+          with_width(@width - 1)
+        else
+          return
+        end
+      Algorithm.move(move)
+    end
 
-        SliceMove.new(@axis_face, @direction, @width - 1)
-      end
+    protected
 
-      # The fat M-slice move inside this fat move.
-      def inner_fat_mslice_move(cube_size)
-        raise ArgumentError unless cube_size.even? && @width == cube_size - 1
+    def merge_with_same_fat_block(other)
+      Algorithm.move(FatMove.new(@axis_face, @direction + other.direction, @width))
+    end
 
-        FatMSliceMove.new(@axis_face, @direction)
-      end
+    def merge_with_opposite_fat_block(other)
+      rotation = Rotation.new(@axis_face, @direction)
+      move = FatMove.new(other.axis_face, other.direction + @direction, other.width)
+      Algorithm.new([move, rotation])
+    end
 
-      def contained_mslice_move?(other, cube_size)
-        same_axis?(other) && @width == cube_size - 1 &&
-          @direction == other.translated_direction(@axis_face).inverse
-      end
+    # The outermost slice move inside this fat move.
+    def inner_slice_move
+      raise ArgumentError unless @width >= 2
 
-      def adjacent_mslice_move?(other)
-        same_axis?(other) && @width == 1 && @direction == other.translated_direction(@axis_face)
-      end
+      SliceMove.new(@axis_face, @direction, @width - 1)
+    end
 
-      def same_fat_block?(other)
-        @axis_face == other.axis_face && @width == other.width
-      end
+    # The fat M-slice move inside this fat move.
+    def inner_fat_mslice_move(cube_size)
+      raise ArgumentError unless cube_size.even? && @width == cube_size - 1
 
-      def leaves_inner_slice_move?(other)
-        @axis_face == other.axis_face && @width == other.width + 1 &&
-          @direction == other.direction.inverse
-      end
+      FatMSliceMove.new(@axis_face, @direction)
+    end
 
-      def leaves_inner_fat_mslice_move?(other, cube_size)
-        cube_size.even? && @axis_face == other.axis_face && @width == cube_size - 1 &&
-          other.width == 1 && @direction == other.direction.inverse
-      end
+    def contained_mslice_move?(other, cube_size)
+      same_axis?(other) && @width == cube_size - 1 &&
+        @direction == other.translated_direction(@axis_face).inverse
+    end
 
-      def opposite_fat_block?(other, cube_size)
-        @axis_face == other.axis_face.opposite && @width + other.width == cube_size
-      end
+    def adjacent_mslice_move?(other)
+      same_axis?(other) && @width == 1 && @direction == other.translated_direction(@axis_face)
     end
 
-    # A slice move of any slice, not necessary the middle one.
-    class SliceMove < CubeMove
-      def initialize(axis_face, direction, slice_index)
-        super(axis_face, direction)
-        raise TypeError unless slice_index.is_a?(Integer)
-        unless slice_index >= 1
-          raise ArgumentError, "Invalid slice index #{slice_index} for slice move."
-        end
+    def same_fat_block?(other)
+      @axis_face == other.axis_face && @width == other.width
+    end
 
-        @slice_index = slice_index
-      end
+    def leaves_inner_slice_move?(other)
+      @axis_face == other.axis_face && @width == other.width + 1 &&
+        @direction == other.direction.inverse
+    end
 
-      attr_reader :slice_index
+    def leaves_inner_fat_mslice_move?(other, cube_size)
+      cube_size.even? && @axis_face == other.axis_face && @width == cube_size - 1 &&
+        other.width == 1 && @direction == other.direction.inverse
+    end
 
-      def identifying_fields
-        super + [@slice_index]
-      end
+    def opposite_fat_block?(other, cube_size)
+      @axis_face == other.axis_face.opposite && @width + other.width == cube_size
+    end
+  end
 
-      def to_s
-        "#{@slice_index > 1 ? @slice_index : ''}#{@axis_face.name.downcase}#{@direction.name}"
+  # A slice move of any slice, not necessary the middle one.
+  class SliceMove < CubeMove
+    def initialize(axis_face, direction, slice_index)
+      super(axis_face, direction)
+      raise TypeError unless slice_index.is_a?(Integer)
+      unless slice_index >= 1
+        raise ArgumentError, "Invalid slice index #{slice_index} for slice move."
       end
 
-      def slice_move?
-        true
-      end
+      @slice_index = slice_index
+    end
 
-      def mirror(normal_face)
-        if normal_face.same_axis?(@axis_face)
-          SliceMove.new(@axis_face.opposite, @direction.inverse, @slice_index)
-        else
-          inverse
-        end
-      end
+    attr_reader :slice_index
 
-      def equivalent_internal?(other, cube_size)
-        return other.equivalent_internal?(self, cube_size) if other.is_a?(FatMSliceMove)
-        return simplified(cube_size) == other.simplified(cube_size) if other.is_a?(SliceMove)
+    def identifying_fields
+      super + [@slice_index]
+    end
 
-        false
-      end
+    def to_s
+      "#{@slice_index > 1 ? @slice_index : ''}#{@axis_face.name.downcase}#{@direction.name}"
+    end
 
-      def translated_slice_index(other_axis_face, cube_size)
-        if @slice_index >= cube_size - 1
-          raise ArgumentError,
-                "Slice index #{@slice_index} of #{self} is invalid for cube size #{cube_size}."
-        end
+    def slice_move?
+      true
+    end
 
-        case @axis_face
-        when other_axis_face then @slice_index
-        when other_axis_face.opposite then invert_slice_index(cube_size)
-        else raise ArgumentError
-        end
+    def mirror(normal_face)
+      if normal_face.same_axis?(@axis_face)
+        SliceMove.new(@axis_face.opposite, @direction.inverse, @slice_index)
+      else
+        inverse
       end
+    end
 
-      def prepend_rotation(_other, _cube_size)
-        nil
-      end
+    def equivalent_internal?(other, cube_size)
+      return other.equivalent_internal?(self, cube_size) if other.is_a?(FatMSliceMove)
+      return simplified(cube_size) == other.simplified(cube_size) if other.is_a?(SliceMove)
 
-      def prepend_fat_m_slice_move(_other, _cube_size)
-        nil
+      false
+    end
+
+    def translated_slice_index(other_axis_face, cube_size)
+      if @slice_index >= cube_size - 1
+        raise ArgumentError,
+              "Slice index #{@slice_index} of #{self} is invalid for cube size #{cube_size}."
       end
 
-      def prepend_fat_move(other, cube_size)
-        # Note that changing the order is safe because that method returns nil if no cancellation
-        # can be performed.
-        other.prepend_slice_move(self, cube_size)
+      case @axis_face
+      when other_axis_face then @slice_index
+      when other_axis_face.opposite then invert_slice_index(cube_size)
+      else raise ArgumentError
       end
+    end
 
-      def prepend_slice_move(other, cube_size)
-        return unless same_axis?(other)
+    def prepend_rotation(_other, _cube_size)
+      nil
+    end
 
-        # Only for 4x4, we can join two adjacent slice moves into a fat m slice move.
-        this = simplified(cube_size)
-        if this.can_join_to_fat_mslice?(other, cube_size)
-          return Algorithm.move(FatMSliceMove.new(other.axis_face, other.direction))
-        end
+    def prepend_fat_m_slice_move(_other, _cube_size)
+      nil
+    end
 
-        other = other.simplified(cube_size)
-        return unless this.same_slice?(other)
+    def prepend_fat_move(other, cube_size)
+      # Note that changing the order is safe because that method returns nil if no cancellation
+      # can be performed.
+      other.prepend_slice_move(self, cube_size)
+    end
 
-        Algorithm.move(
-          SliceMove.new(
-            other.axis_face,
-            other.direction + this.translated_direction(other.axis_face),
-            other.slice_index
-          )
-        )
+    def prepend_slice_move(other, cube_size)
+      return unless same_axis?(other)
+
+      # Only for 4x4, we can join two adjacent slice moves into a fat m slice move.
+      this = simplified(cube_size)
+      if this.can_join_to_fat_mslice?(other, cube_size)
+        return Algorithm.move(FatMSliceMove.new(other.axis_face, other.direction))
       end
 
-      protected
+      other = other.simplified(cube_size)
+      return unless this.same_slice?(other)
 
-      def simplified(cube_size)
-        if @slice_index >= cube_size - 1
-          raise ArgumentError,
-                "Slice index #{@slice_index} of #{self} is invalid for cube size #{cube_size}."
-        end
+      Algorithm.move(
+        SliceMove.new(
+          other.axis_face,
+          other.direction + this.translated_direction(other.axis_face),
+          other.slice_index
+        )
+      )
+    end
 
-        if @slice_index >= (cube_size + 1) / 2
-          SliceMove.new(@axis_face.opposite, @direction.inverse, invert_slice_index(cube_size))
-        else
-          self
-        end
-      end
+    protected
 
-      def invert_slice_index(cube_size)
-        cube_size - 1 - @slice_index
+    def simplified(cube_size)
+      if @slice_index >= cube_size - 1
+        raise ArgumentError,
+              "Slice index #{@slice_index} of #{self} is invalid for cube size #{cube_size}."
       end
 
-      # Note that this is only a partial implementation of what we need internally.
-      # It does NOT get all cases correctly because there might be equivalent versions of the
-      # same slice move.
-      def can_join_to_fat_mslice?(other, cube_size)
-        cube_size == 4 && @slice_index == 1 &&
-          mirror(@axis_face).equivalent_internal?(other, cube_size)
+      if @slice_index >= (cube_size + 1) / 2
+        SliceMove.new(@axis_face.opposite, @direction.inverse, invert_slice_index(cube_size))
+      else
+        self
       end
+    end
 
-      # Note that this is only a partial implementation of what we need internally.
-      # It does NOT get all cases correctly because there might be equivalent versions of the
-      # same slice move.
-      def same_slice?(other)
-        @axis_face == other.axis_face && @slice_index == other.slice_index
-      end
+    def invert_slice_index(cube_size)
+      cube_size - 1 - @slice_index
     end
 
-    # Inner M slice moves that move only one middle layer.
-    class InnerMSliceMove < SliceMove
-      include MSlicePrintHelper
+    # Note that this is only a partial implementation of what we need internally.
+    # It does NOT get all cases correctly because there might be equivalent versions of the
+    # same slice move.
+    def can_join_to_fat_mslice?(other, cube_size)
+      cube_size == 4 && @slice_index == 1 &&
+        mirror(@axis_face).equivalent_internal?(other, cube_size)
     end
 
-    # Not that this represents a move that is written as 'u' which is a slice move on bigger cubes
-    # but a fat move on 3x3...
-    class MaybeFatMaybeSliceMove < CubeMove
-      # We handle the annoying inconsistency that u is a slice move for bigger cubes, but a fat move
-      # for 3x3.
-      def decide_meaning(cube_size)
-        case cube_size
-        when 2 then raise ArgumentError
-        when 3 then FatMove.new(@axis_face, @direction, 2)
-        else SliceMove.new(@axis_face, @direction, 1)
-        end
+    # Note that this is only a partial implementation of what we need internally.
+    # It does NOT get all cases correctly because there might be equivalent versions of the
+    # same slice move.
+    def same_slice?(other)
+      @axis_face == other.axis_face && @slice_index == other.slice_index
+    end
+  end
+
+  # Inner M slice moves that move only one middle layer.
+  class InnerMSliceMove < SliceMove
+    include MSlicePrintHelper
+  end
+
+  # Not that this represents a move that is written as 'u' which is a slice move on bigger cubes
+  # but a fat move on 3x3...
+  class MaybeFatMaybeSliceMove < CubeMove
+    # We handle the annoying inconsistency that u is a slice move for bigger cubes, but a fat move
+    # for 3x3.
+    def decide_meaning(cube_size)
+      case cube_size
+      when 2 then raise ArgumentError
+      when 3 then FatMove.new(@axis_face, @direction, 2)
+      else SliceMove.new(@axis_face, @direction, 1)
       end
+    end
 
-      def to_s
-        "#{@axis_face.name.downcase}#{@direction.name}"
-      end
+    def to_s
+      "#{@axis_face.name.downcase}#{@direction.name}"
     end
+  end
 end