twisty_puzzles 0.0.1 → 0.0.2

data/lib/twisty_puzzles/commutator.rb

@@ -5,114 +5,113 @@ require 'twisty_puzzles/algorithm'
 require 'twisty_puzzles/cube'
 
 module TwistyPuzzles
-  
-    # Base class for Commutators.
-    class Commutator
-      def cancellations(other, cube_size, metric = :htm)
-        algorithm.cancellations(other.algorithm, cube_size, metric)
-      end
+  # Base class for Commutators.
+  class Commutator
+    def cancellations(other, cube_size, metric = :htm)
+      algorithm.cancellations(other.algorithm, cube_size, metric)
     end
+  end
 
-    # Algorithm that is used like a commutator but actually isn't one.
-    class FakeCommutator < Commutator
-      def initialize(algorithm)
-        raise ArgumentError unless algorithm.is_a?(Algorithm)
-
-        @algorithm = algorithm
-      end
+  # Algorithm that is used like a commutator but actually isn't one.
+  class FakeCommutator < Commutator
+    def initialize(algorithm)
+      raise ArgumentError unless algorithm.is_a?(Algorithm)
 
-      attr_reader :algorithm
+      @algorithm = algorithm
+    end
 
-      def eql?(other)
-        self.class.equal?(other.class) && @algorithm == other.algorithm
-      end
+    attr_reader :algorithm
 
-      alias == eql?
+    def eql?(other)
+      self.class.equal?(other.class) && @algorithm == other.algorithm
+    end
 
-      def hash
-        @hash ||= [self.class, @algorithm].hash
-      end
+    alias == eql?
 
-      def inverse
-        FakeCommutator.new(@algorithm.inverse)
-      end
+    def hash
+      @hash ||= [self.class, @algorithm].hash
+    end
 
-      def to_s
-        @algorithm.to_s
-      end
+    def inverse
+      FakeCommutator.new(@algorithm.inverse)
     end
 
-    # Pure commutator of the form A B A' B'.
-    class PureCommutator < Commutator
-      def initialize(first_part, second_part)
-        raise ArgumentError unless first_part.is_a?(Algorithm)
-        raise ArgumentError unless second_part.is_a?(Algorithm)
+    def to_s
+      @algorithm.to_s
+    end
+  end
 
-        @first_part = first_part
-        @second_part = second_part
-      end
+  # Pure commutator of the form A B A' B'.
+  class PureCommutator < Commutator
+    def initialize(first_part, second_part)
+      raise ArgumentError unless first_part.is_a?(Algorithm)
+      raise ArgumentError unless second_part.is_a?(Algorithm)
 
-      attr_reader :first_part, :second_part
+      @first_part = first_part
+      @second_part = second_part
+    end
 
-      def eql?(other)
-        self.class.equal?(other.class) && @first_part == other.first_part &&
-          @second_part == other.second_part
-      end
+    attr_reader :first_part, :second_part
 
-      alias == eql?
+    def eql?(other)
+      self.class.equal?(other.class) && @first_part == other.first_part &&
+        @second_part == other.second_part
+    end
 
-      def hash
-        @hash ||= [self.class, @first_part, @second_part].hash
-      end
+    alias == eql?
 
-      def inverse
-        PureCommutator.new(second_part, first_part)
-      end
+    def hash
+      @hash ||= [self.class, @first_part, @second_part].hash
+    end
 
-      def to_s
-        "[#{@first_part}, #{@second_part}]"
-      end
+    def inverse
+      PureCommutator.new(second_part, first_part)
+    end
 
-      def algorithm
-        first_part + second_part + first_part.inverse + second_part.inverse
-      end
+    def to_s
+      "[#{@first_part}, #{@second_part}]"
     end
 
-    # Setup commutator of the form A B A'.
-    class SetupCommutator < Commutator
-      def initialize(setup, inner_commutator)
-        raise ArgumentError, 'Setup move has to be an algorithm.' unless setup.is_a?(Algorithm)
-        unless inner_commutator.is_a?(Commutator)
-          raise ArgumentError, 'Inner commutator has to be a commutator.'
-        end
+    def algorithm
+      first_part + second_part + first_part.inverse + second_part.inverse
+    end
+  end
 
-        @setup = setup
-        @inner_commutator = inner_commutator
+  # Setup commutator of the form A B A'.
+  class SetupCommutator < Commutator
+    def initialize(setup, inner_commutator)
+      raise ArgumentError, 'Setup move has to be an algorithm.' unless setup.is_a?(Algorithm)
+      unless inner_commutator.is_a?(Commutator)
+        raise ArgumentError, 'Inner commutator has to be a commutator.'
       end
 
-      attr_reader :setup, :inner_commutator
+      @setup = setup
+      @inner_commutator = inner_commutator
+    end
+
+    attr_reader :setup, :inner_commutator
 
-      def eql?(other)
-        self.class.equal?(other.class) && @setup == other.setup &&
-          @inner_commutator == other.inner_commutator
-      end
+    def eql?(other)
+      self.class.equal?(other.class) && @setup == other.setup &&
+        @inner_commutator == other.inner_commutator
+    end
 
-      alias == eql?
+    alias == eql?
 
-      def hash
-        @hash ||= [self.class, @setup, @inner_commutator].hash
-      end
+    def hash
+      @hash ||= [self.class, @setup, @inner_commutator].hash
+    end
 
-      def inverse
-        SetupCommutator.new(setup, @inner_commutator.inverse)
-      end
+    def inverse
+      SetupCommutator.new(setup, @inner_commutator.inverse)
+    end
 
-      def to_s
-        "[#{@setup} : #{@inner_commutator}]"
-      end
+    def to_s
+      "[#{@setup} : #{@inner_commutator}]"
+    end
 
-      def algorithm
-        setup + inner_commutator.algorithm + setup.inverse
-      end
+    def algorithm
+      setup + inner_commutator.algorithm + setup.inverse
     end
+  end
 end

data/lib/twisty_puzzles/compiled_algorithm.rb

@@ -3,46 +3,45 @@
 require 'twisty_puzzles/reversible_applyable'
 
 module TwistyPuzzles
-  
-    # Base class for a compiled algorithm for a particular puzzle.
-    class CompiledAlgorithm
-      include ReversibleApplyable
+  # Base class for a compiled algorithm for a particular puzzle.
+  class CompiledAlgorithm
+    include ReversibleApplyable
 
-      def initialize(native)
-        raise TypeError unless native.is_a?(self.class::NATIVE_CLASS)
+    def initialize(native)
+      raise TypeError unless native.is_a?(self.class::NATIVE_CLASS)
 
-        @native = native
-      end
+      @native = native
+    end
 
-      attr_reader :native
+    attr_reader :native
 
-      def rotate_by(rotation)
-        self.class.new(@native.rotate_by(rotation.axis_face.face_symbol, rotation.direction.value))
-      end
+    def rotate_by(rotation)
+      self.class.new(@native.rotate_by(rotation.axis_face.face_symbol, rotation.direction.value))
+    end
 
-      def mirror(normal_face)
-        self.class.new(@native.mirror(normal_face.face_symbol))
-      end
+    def mirror(normal_face)
+      self.class.new(@native.mirror(normal_face.face_symbol))
+    end
 
-      def inverse
-        @inverse ||=
-          begin
-                                alg = self.class.new(@native.inverse)
-                                alg.inverse = self
-                                alg
-                              end
-      end
+    def inverse
+      @inverse ||=
+        begin
+                              alg = self.class.new(@native.inverse)
+                              alg.inverse = self
+                              alg
+                            end
+    end
 
-      def +(other)
-        self.class.new(@native + other.native)
-      end
+    def +(other)
+      self.class.new(@native + other.native)
+    end
 
-      def apply_to(state)
-        @native.apply_to(state.native)
-      end
+    def apply_to(state)
+      @native.apply_to(state.native)
+    end
 
-      protected
+    protected
 
-      attr_writer :inverse
-    end
+    attr_writer :inverse
+  end
 end

data/lib/twisty_puzzles/compiled_cube_algorithm.rb

@@ -3,65 +3,64 @@
 require 'twisty_puzzles/compiled_algorithm'
 
 module TwistyPuzzles
-  
-    # Wrapper of the native C implementation of a compiled algorithm for a particular cube size.
-    class CompiledCubeAlgorithm < CompiledAlgorithm
-      def self.transform_rotation(move, cube_size)
-        slice_moves =
-          0.upto(cube_size - 1).map do |i|
-            [:slice, move.axis_face.face_symbol, move.direction.value, i]
-          end
-        [
-          [:face, move.axis_face.face_symbol, move.direction.value],
-          [:face, move.axis_face.opposite.face_symbol, move.direction.inverse.value]
-        ] + slice_moves
-      end
-
-      def self.transform_fat_mslice_move(move, cube_size)
-        1.upto(cube_size - 2).map do |i|
+  # Wrapper of the native C implementation of a compiled algorithm for a particular cube size.
+  class CompiledCubeAlgorithm < CompiledAlgorithm
+    def self.transform_rotation(move, cube_size)
+      slice_moves =
+        0.upto(cube_size - 1).map do |i|
           [:slice, move.axis_face.face_symbol, move.direction.value, i]
         end
-      end
-
-      def self.transform_slice_move(move)
-        [
-          [:slice, move.axis_face.face_symbol, move.direction.value, move.slice_index]
-        ]
-      end
+      [
+        [:face, move.axis_face.face_symbol, move.direction.value],
+        [:face, move.axis_face.opposite.face_symbol, move.direction.inverse.value]
+      ] + slice_moves
+    end
 
-      def self.transform_fat_move(move)
-        slice_moves =
-          0.upto(move.width - 1).map do |i|
-            [:slice, move.axis_face.face_symbol, move.direction.value, i]
-          end
-        [
-          [:face, move.axis_face.face_symbol, move.direction.value]
-        ] + slice_moves
+    def self.transform_fat_mslice_move(move, cube_size)
+      1.upto(cube_size - 2).map do |i|
+        [:slice, move.axis_face.face_symbol, move.direction.value, i]
       end
+    end
 
-      private_class_method :transform_rotation, :transform_fat_mslice_move, :transform_slice_move,
-                           :transform_fat_move
+    def self.transform_slice_move(move)
+      [
+        [:slice, move.axis_face.face_symbol, move.direction.value, move.slice_index]
+      ]
+    end
 
-      def self.transform_move(move, cube_size)
-        decided_move = move.decide_meaning(cube_size)
-        case decided_move
-        when Rotation then transform_rotation(decided_move, cube_size)
-        when FatMSliceMove then transform_fat_mslice_move(decided_move, cube_size)
-        # Note that this also covers InnerMSliceMove
-        when SliceMove then transform_slice_move(decided_move)
-        when FatMove then transform_fat_move(decided_move)
-        else
-          raise TypeError, "Invalid move type #{move.class} that becomes #{decided_move.class} "\
-                           "for cube size #{cube_size}."
+    def self.transform_fat_move(move)
+      slice_moves =
+        0.upto(move.width - 1).map do |i|
+          [:slice, move.axis_face.face_symbol, move.direction.value, i]
         end
-      end
+      [
+        [:face, move.axis_face.face_symbol, move.direction.value]
+      ] + slice_moves
+    end
 
-      def self.for_moves(cube_size, moves)
-        transformed_moves = moves.collect_concat { |m| transform_move(m, cube_size) }
-        native = Native::CubeAlgorithm.new(cube_size, transformed_moves)
-        new(native)
+    private_class_method :transform_rotation, :transform_fat_mslice_move, :transform_slice_move,
+                         :transform_fat_move
+
+    def self.transform_move(move, cube_size)
+      decided_move = move.decide_meaning(cube_size)
+      case decided_move
+      when Rotation then transform_rotation(decided_move, cube_size)
+      when FatMSliceMove then transform_fat_mslice_move(decided_move, cube_size)
+      # Note that this also covers InnerMSliceMove
+      when SliceMove then transform_slice_move(decided_move)
+      when FatMove then transform_fat_move(decided_move)
+      else
+        raise TypeError, "Invalid move type #{move.class} that becomes #{decided_move.class} "\
+                         "for cube size #{cube_size}."
       end
+    end
 
-      NATIVE_CLASS = Native::CubeAlgorithm
+    def self.for_moves(cube_size, moves)
+      transformed_moves = moves.collect_concat { |m| transform_move(m, cube_size) }
+      native = Native::CubeAlgorithm.new(cube_size, transformed_moves)
+      new(native)
     end
+
+    NATIVE_CLASS = Native::CubeAlgorithm
+  end
 end

data/lib/twisty_puzzles/compiled_skewb_algorithm.rb

@@ -3,26 +3,25 @@
 require 'twisty_puzzles/compiled_algorithm'
 
 module TwistyPuzzles
-  
-    # Wrapper of the native C implementation of a compiled algorithm for a particular cube size.
-    class CompiledSkewbAlgorithm < CompiledAlgorithm
-      def self.transform_move(move)
-        case move
-        when Rotation
-          [:rotation, move.axis_face.face_symbol, move.direction.value]
-        when SkewbMove
-          [:move, move.axis_corner.face_symbols, move.direction.value]
-        else
-          raise TypeError
-        end
-      end
-
-      def self.for_moves(moves)
-        native = Native::SkewbAlgorithm.new(moves.map { |m| transform_move(m) })
-        new(native)
+  # Wrapper of the native C implementation of a compiled algorithm for a particular cube size.
+  class CompiledSkewbAlgorithm < CompiledAlgorithm
+    def self.transform_move(move)
+      case move
+      when Rotation
+        [:rotation, move.axis_face.face_symbol, move.direction.value]
+      when SkewbMove
+        [:move, move.axis_corner.face_symbols, move.direction.value]
+      else
+        raise TypeError
       end
+    end
 
-      NATIVE_CLASS = Native::SkewbAlgorithm
-      EMPTY = for_moves([])
+    def self.for_moves(moves)
+      native = Native::SkewbAlgorithm.new(moves.map { |m| transform_move(m) })
+      new(native)
     end
+
+    NATIVE_CLASS = Native::SkewbAlgorithm
+    EMPTY = for_moves([])
+  end
 end

data/lib/twisty_puzzles/coordinate.rb

@@ -5,314 +5,313 @@ require 'twisty_puzzles/cube_constants'
 require 'twisty_puzzles/native'
 
 module TwistyPuzzles
-  
-    # Coordinate of a sticker on the cube.
-    class Coordinate
-      def self.highest_coordinate(cube_size)
-        cube_size - 1
-      end
-
-      def self.invert_coordinate(index, cube_size)
-        highest_coordinate(cube_size) - index
-      end
+  # Coordinate of a sticker on the cube.
+  class Coordinate
+    def self.highest_coordinate(cube_size)
+      cube_size - 1
+    end
 
-      def self.coordinate_range(cube_size)
-        0.upto(highest_coordinate(cube_size))
-      end
+    def self.invert_coordinate(index, cube_size)
+      highest_coordinate(cube_size) - index
+    end
 
-      def self.middle(cube_size)
-        raise ArgumentError if cube_size.even?
+    def self.coordinate_range(cube_size)
+      0.upto(highest_coordinate(cube_size))
+    end
 
-        cube_size / 2
-      end
+    def self.middle(cube_size)
+      raise ArgumentError if cube_size.even?
 
-      # Middle coordinate for uneven numbers, the one before for even numbers
-      def self.middle_or_before(cube_size)
-        cube_size - cube_size / 2 - 1
-      end
+      cube_size / 2
+    end
 
-      # Middle coordinate for uneven numbers, the one after for even numbers
-      def self.middle_or_after(cube_size)
-        cube_size / 2
-      end
+    # Middle coordinate for uneven numbers, the one before for even numbers
+    def self.middle_or_before(cube_size)
+      cube_size - cube_size / 2 - 1
+    end
 
-      # The last coordinate that is strictly before the middle
-      def self.last_before_middle(cube_size)
-        cube_size / 2 - 1
-      end
+    # Middle coordinate for uneven numbers, the one after for even numbers
+    def self.middle_or_after(cube_size)
+      cube_size / 2
+    end
 
-      def self.canonicalize(index, cube_size)
-        raise ArgumentError unless index.is_a?(Integer) && -cube_size <= index && index < cube_size
+    # The last coordinate that is strictly before the middle
+    def self.last_before_middle(cube_size)
+      cube_size / 2 - 1
+    end
 
-        index >= 0 ? index : cube_size + index
-      end
+    def self.canonicalize(index, cube_size)
+      raise ArgumentError unless index.is_a?(Integer) && -cube_size <= index && index < cube_size
 
-      def self.from_face_distances(face, cube_size, face_distances)
-        raise ArgumentError if face_distances.length != 2
-
-        coordinates = [nil, nil]
-        face_distances.each do |neighbor, distance|
-          index = face.coordinate_index_close_to(neighbor)
-          coordinate =
-            if neighbor.close_to_smaller_indices?
-              distance
-            else
-              invert_coordinate(distance, cube_size)
-            end
-          raise ArgumentError if coordinates[index]
-
-          coordinates[index] = coordinate
-        end
-        raise ArgumentError if coordinates.any?(&:nil?)
+      index >= 0 ? index : cube_size + index
+    end
 
-        from_indices(face, cube_size, *coordinates)
-      end
+    def self.from_face_distances(face, cube_size, face_distances)
+      raise ArgumentError if face_distances.length != 2
 
-      def self.match_coordinate_internal(base_coordinate, other_face_symbols)
-        other_face_symbols.sort!
+      coordinates = [nil, nil]
+      face_distances.each do |neighbor, distance|
+        index = face.coordinate_index_close_to(neighbor)
         coordinate =
-          base_coordinate.rotations.find do |coord|
-            face_symbols_closeby = coord.close_neighbor_faces.map(&:face_symbol)
-            face_symbols_closeby.sort == other_face_symbols
+          if neighbor.close_to_smaller_indices?
+            distance
+          else
+            invert_coordinate(distance, cube_size)
           end
-        raise "Couldn't find a fitting coordinate on the solved face." if coordinate.nil?
+        raise ArgumentError if coordinates[index]
 
-        coordinate
+        coordinates[index] = coordinate
       end
+      raise ArgumentError if coordinates.any?(&:nil?)
 
-      # The coordinate of the solved position of the main sticker of this part.
-      def self.solved_position(part, cube_size, incarnation_index)
-        raise TypeError unless part.is_a?(Part)
-        raise unless part.class::ELEMENTS.length == 24
-        raise unless incarnation_index >= 0 && incarnation_index < part.num_incarnations(cube_size)
-
-        # This is a coordinate on the same face and belonging to an equivalent part.
-        # But it might not be the right one.
-        base_coordinate = Coordinate.from_indices(
-          part.solved_face, cube_size, *part.base_index_on_face(cube_size, incarnation_index)
-        )
-        other_face_symbols = part.corresponding_part.face_symbols[1..-1]
-        match_coordinate_internal(base_coordinate, other_face_symbols)
-      end
+      from_indices(face, cube_size, *coordinates)
+    end
 
-      # The coordinate of the solved position of all stickers of this part.
-      # rubocop:disable Metrics/AbcSize
-      def self.solved_positions(part, cube_size, incarnation_index)
-        solved_coordinate = solved_position(part, cube_size, incarnation_index)
-        other_coordinates =
-          part.face_symbols[1..-1].map.with_index do |f, i|
-            face = Face.for_face_symbol(f)
-            # The reverse is important for edge like parts. We are not in the same position as usual
-            # solved pieces would be.
-            # For other types of pieces, it doesn't make a difference as the base index will just be
-            # a rotation of the original one, but we will anyway look at all rotations later.
-            base_indices = part.base_index_on_other_face(face, cube_size, incarnation_index).reverse
-            base_coordinate = Coordinate.from_indices(face, cube_size, *base_indices)
-            other_face_symbols = [part.face_symbols[0]] +
-                                 part.corresponding_part.face_symbols[1...i + 1] +
-                                 part.corresponding_part.face_symbols[i + 2..-1]
-            match_coordinate_internal(base_coordinate, other_face_symbols)
-          end
-        [solved_coordinate] + other_coordinates
-      end
-      # rubocop:enable Metrics/AbcSize
+    def self.match_coordinate_internal(base_coordinate, other_face_symbols)
+      other_face_symbols.sort!
+      coordinate =
+        base_coordinate.rotations.find do |coord|
+          face_symbols_closeby = coord.close_neighbor_faces.map(&:face_symbol)
+          face_symbols_closeby.sort == other_face_symbols
+        end
+      raise "Couldn't find a fitting coordinate on the solved face." if coordinate.nil?
 
-      def self.center(face, cube_size)
-        m = middle(cube_size)
-        from_indices(face, cube_size, m, m)
-      end
+      coordinate
+    end
 
-      def self.edges_outside(face, cube_size)
-        face.neighbors.zip(face.neighbors.rotate(1)).collect_concat do |neighbor, next_neighbor|
-          1.upto(cube_size - 2).map do |i|
-            from_face_distances(neighbor, cube_size, face => 0, next_neighbor => i)
-          end
+    # The coordinate of the solved position of the main sticker of this part.
+    def self.solved_position(part, cube_size, incarnation_index)
+      raise TypeError unless part.is_a?(Part)
+      raise unless part.class::ELEMENTS.length == 24
+      raise unless incarnation_index >= 0 && incarnation_index < part.num_incarnations(cube_size)
+
+      # This is a coordinate on the same face and belonging to an equivalent part.
+      # But it might not be the right one.
+      base_coordinate = Coordinate.from_indices(
+        part.solved_face, cube_size, *part.base_index_on_face(cube_size, incarnation_index)
+      )
+      other_face_symbols = part.corresponding_part.face_symbols[1..-1]
+      match_coordinate_internal(base_coordinate, other_face_symbols)
+    end
+
+    # The coordinate of the solved position of all stickers of this part.
+    # rubocop:disable Metrics/AbcSize
+    def self.solved_positions(part, cube_size, incarnation_index)
+      solved_coordinate = solved_position(part, cube_size, incarnation_index)
+      other_coordinates =
+        part.face_symbols[1..-1].map.with_index do |f, i|
+          face = Face.for_face_symbol(f)
+          # The reverse is important for edge like parts. We are not in the same position as usual
+          # solved pieces would be.
+          # For other types of pieces, it doesn't make a difference as the base index will just be
+          # a rotation of the original one, but we will anyway look at all rotations later.
+          base_indices = part.base_index_on_other_face(face, cube_size, incarnation_index).reverse
+          base_coordinate = Coordinate.from_indices(face, cube_size, *base_indices)
+          other_face_symbols = [part.face_symbols[0]] +
+                               part.corresponding_part.face_symbols[1...i + 1] +
+                               part.corresponding_part.face_symbols[i + 2..-1]
+          match_coordinate_internal(base_coordinate, other_face_symbols)
         end
-      end
+      [solved_coordinate] + other_coordinates
+    end
+    # rubocop:enable Metrics/AbcSize
 
-      def self.from_indices(face, cube_size, x_index, y_index)
-        raise TypeError, "Unsuitable face #{face.inspect}." unless face.is_a?(Face)
-        raise TypeError unless cube_size.is_a?(Integer)
-        raise ArgumentError unless cube_size.positive?
-
-        x = Coordinate.canonicalize(x_index, cube_size)
-        y = Coordinate.canonicalize(y_index, cube_size)
-        native = Native::CubeCoordinate.new(
-          cube_size,
-          face.face_symbol,
-          face.coordinate_index_base_face(0).face_symbol,
-          face.coordinate_index_base_face(1).face_symbol,
-          x,
-          y
-        )
-        new(native)
+    def self.center(face, cube_size)
+      m = middle(cube_size)
+      from_indices(face, cube_size, m, m)
+    end
+
+    def self.edges_outside(face, cube_size)
+      face.neighbors.zip(face.neighbors.rotate(1)).collect_concat do |neighbor, next_neighbor|
+        1.upto(cube_size - 2).map do |i|
+          from_face_distances(neighbor, cube_size, face => 0, next_neighbor => i)
+        end
       end
+    end
 
-      private_class_method :new
+    def self.from_indices(face, cube_size, x_index, y_index)
+      raise TypeError, "Unsuitable face #{face.inspect}." unless face.is_a?(Face)
+      raise TypeError unless cube_size.is_a?(Integer)
+      raise ArgumentError unless cube_size.positive?
+
+      x = Coordinate.canonicalize(x_index, cube_size)
+      y = Coordinate.canonicalize(y_index, cube_size)
+      native = Native::CubeCoordinate.new(
+        cube_size,
+        face.face_symbol,
+        face.coordinate_index_base_face(0).face_symbol,
+        face.coordinate_index_base_face(1).face_symbol,
+        x,
+        y
+      )
+      new(native)
+    end
 
-      def initialize(native)
-        raise TypeError unless native.is_a?(Native::CubeCoordinate)
+    private_class_method :new
 
-        @native = native
-      end
+    def initialize(native)
+      raise TypeError unless native.is_a?(Native::CubeCoordinate)
 
-      attr_reader :native
+      @native = native
+    end
 
-      def face
-        @face ||= Face.for_face_symbol(@native.face)
-      end
+    attr_reader :native
 
-      def cube_size
-        @cube_size ||= @native.cube_size
-      end
+    def face
+      @face ||= Face.for_face_symbol(@native.face)
+    end
 
-      def coordinate(coordinate_index)
-        native.coordinate(face.coordinate_index_base_face(coordinate_index).face_symbol)
-      end
+    def cube_size
+      @cube_size ||= @native.cube_size
+    end
 
-      def coordinates
-        @coordinates ||= [x, y].freeze
-      end
+    def coordinate(coordinate_index)
+      native.coordinate(face.coordinate_index_base_face(coordinate_index).face_symbol)
+    end
 
-      def x
-        @x ||= coordinate(0)
-      end
+    def coordinates
+      @coordinates ||= [x, y].freeze
+    end
 
-      def y
-        @y ||= coordinate(1)
-      end
+    def x
+      @x ||= coordinate(0)
+    end
 
-      def eql?(other)
-        self.class.equal?(other.class) && @native == other.native
-      end
+    def y
+      @y ||= coordinate(1)
+    end
 
-      alias == eql?
+    def eql?(other)
+      self.class.equal?(other.class) && @native == other.native
+    end
 
-      def hash
-        [self.class, @native].hash
-      end
+    alias == eql?
 
-      def can_jump_to?(to_face)
-        raise ArgumentError unless to_face.is_a?(Face)
+    def hash
+      [self.class, @native].hash
+    end
 
-        jump_coordinate_index = face.coordinate_index_close_to(to_face)
-        jump_coordinate = coordinates[jump_coordinate_index]
-        (jump_coordinate.zero? && to_face.close_to_smaller_indices?) ||
-          (jump_coordinate == Coordinate.highest_coordinate(cube_size) &&
-           !to_face.close_to_smaller_indices?)
-      end
+    def can_jump_to?(to_face)
+      raise ArgumentError unless to_face.is_a?(Face)
 
-      def jump_to_neighbor(to_face)
-        raise ArgumentError unless to_face.is_a?(Face)
-        raise ArgumentError unless face.neighbors.include?(to_face)
-        raise ArgumentError unless can_jump_to?(to_face)
+      jump_coordinate_index = face.coordinate_index_close_to(to_face)
+      jump_coordinate = coordinates[jump_coordinate_index]
+      (jump_coordinate.zero? && to_face.close_to_smaller_indices?) ||
+        (jump_coordinate == Coordinate.highest_coordinate(cube_size) &&
+         !to_face.close_to_smaller_indices?)
+    end
 
-        new_coordinates = coordinates.dup
-        new_coordinate_index = to_face.coordinate_index_close_to(face)
-        new_coordinate = make_coordinate_at_edge_to(face)
-        new_coordinates.insert(new_coordinate_index, new_coordinate)
-        Coordinate.from_indices(to_face, cube_size, *new_coordinates)
-      end
+    def jump_to_neighbor(to_face)
+      raise ArgumentError unless to_face.is_a?(Face)
+      raise ArgumentError unless face.neighbors.include?(to_face)
+      raise ArgumentError unless can_jump_to?(to_face)
 
-      def jump_to_coordinates(new_coordinates)
-        Coordinate.from_indices(@face, @cube_size, *new_coordinates)
-      end
+      new_coordinates = coordinates.dup
+      new_coordinate_index = to_face.coordinate_index_close_to(face)
+      new_coordinate = make_coordinate_at_edge_to(face)
+      new_coordinates.insert(new_coordinate_index, new_coordinate)
+      Coordinate.from_indices(to_face, cube_size, *new_coordinates)
+    end
 
-      def make_coordinate_at_edge_to(face)
-        face.close_to_smaller_indices? ? 0 : Coordinate.highest_coordinate(cube_size)
-      end
+    def jump_to_coordinates(new_coordinates)
+      Coordinate.from_indices(@face, @cube_size, *new_coordinates)
+    end
 
-      # Returns neighbor faces that are closer to this coordinate than their opposite face.
-      def close_neighbor_faces
-        face.neighbors.select do |neighbor|
-          coordinate = coordinates[face.coordinate_index_close_to(neighbor)]
-          if neighbor.close_to_smaller_indices?
-            before_middle?(coordinate)
-          else
-            after_middle?(coordinate)
-          end
-        end
-      end
+    def make_coordinate_at_edge_to(face)
+      face.close_to_smaller_indices? ? 0 : Coordinate.highest_coordinate(cube_size)
+    end
 
-      def after_middle?(index)
-        Coordinate.canonicalize(index, cube_size) > Coordinate.middle_or_before(cube_size)
+    # Returns neighbor faces that are closer to this coordinate than their opposite face.
+    def close_neighbor_faces
+      face.neighbors.select do |neighbor|
+        coordinate = coordinates[face.coordinate_index_close_to(neighbor)]
+        if neighbor.close_to_smaller_indices?
+          before_middle?(coordinate)
+        else
+          after_middle?(coordinate)
+        end
       end
+    end
 
-      def before_middle?(index)
-        Coordinate.canonicalize(index, cube_size) <= Coordinate.last_before_middle(cube_size)
-      end
+    def after_middle?(index)
+      Coordinate.canonicalize(index, cube_size) > Coordinate.middle_or_before(cube_size)
+    end
 
-      # On a nxn grid with integer coordinates between 0 and n - 1, iterates between the 4 points
-      # that point (x, y) hits if you rotate by 90 degrees.
-      def rotate
-        jump_to_coordinates([y, Coordinate.invert_coordinate(x, cube_size)])
-      end
+    def before_middle?(index)
+      Coordinate.canonicalize(index, cube_size) <= Coordinate.last_before_middle(cube_size)
+    end
 
-      # On a nxn grid with integer coordinates between 0 and n - 1, give the 4 points that point
-      # (x, y) hits if you do a full rotation of the face in clockwise order.
-      def rotations
-        rots = []
-        current = self
-        4.times do
-          rots.push(current)
-          current = current.rotate
-        end
-        raise unless current == self
+    # On a nxn grid with integer coordinates between 0 and n - 1, iterates between the 4 points
+    # that point (x, y) hits if you rotate by 90 degrees.
+    def rotate
+      jump_to_coordinates([y, Coordinate.invert_coordinate(x, cube_size)])
+    end
 
-        rots
+    # On a nxn grid with integer coordinates between 0 and n - 1, give the 4 points that point
+    # (x, y) hits if you do a full rotation of the face in clockwise order.
+    def rotations
+      rots = []
+      current = self
+      4.times do
+        rots.push(current)
+        current = current.rotate
       end
-    end
+      raise unless current == self
 
-    # Coordinate of a sticker on the Skewb.
-    class SkewbCoordinate
-      include Comparable
-      include CubeConstants
-      def initialize(face, coordinate, native)
-        raise ArgumentError, "Unsuitable face #{face.inspect}." unless face.is_a?(Face)
-        unless coordinate.is_a?(Integer) && coordinate >= 0 && coordinate < SKEWB_STICKERS
-          raise ArgumentError
-        end
+      rots
+    end
+  end
 
-        @coordinate = coordinate
-        @native = native
+  # Coordinate of a sticker on the Skewb.
+  class SkewbCoordinate
+    include Comparable
+    include CubeConstants
+    def initialize(face, coordinate, native)
+      raise ArgumentError, "Unsuitable face #{face.inspect}." unless face.is_a?(Face)
+      unless coordinate.is_a?(Integer) && coordinate >= 0 && coordinate < SKEWB_STICKERS
+        raise ArgumentError
       end
 
-      attr_reader :native
+      @coordinate = coordinate
+      @native = native
+    end
 
-      private_class_method :new
+    attr_reader :native
 
-      def self.for_center(face)
-        native = Native::SkewbCoordinate.for_center(face.face_symbol)
-        new(face, 0, native)
-      end
+    private_class_method :new
 
-      def self.corners_on_face(face)
-        face.clockwise_corners.map { |c| for_corner(c) }
-      end
+    def self.for_center(face)
+      native = Native::SkewbCoordinate.for_center(face.face_symbol)
+      new(face, 0, native)
+    end
 
-      def self.for_corner(corner)
-        native = Native::SkewbCoordinate.for_corner(corner.face_symbols)
-        new(Face.for_face_symbol(corner.face_symbols.first), 1 + corner.piece_index % 4, native)
-      end
+    def self.corners_on_face(face)
+      face.clockwise_corners.map { |c| for_corner(c) }
+    end
 
-      def hash
-        @hash ||= [self.class, @native].hash
-      end
+    def self.for_corner(corner)
+      native = Native::SkewbCoordinate.for_corner(corner.face_symbols)
+      new(Face.for_face_symbol(corner.face_symbols.first), 1 + corner.piece_index % 4, native)
+    end
 
-      def eql?(other)
-        @native.eql?(other.native)
-      end
+    def hash
+      @hash ||= [self.class, @native].hash
+    end
 
-      alias == eql?
+    def eql?(other)
+      @native.eql?(other.native)
+    end
 
-      def <=>(other)
-        @native <=> other.native
-      end
+    alias == eql?
 
-      def face
-        @face ||= Face.for_face_symbol(@native.face)
-      end
+    def <=>(other)
+      @native <=> other.native
+    end
 
-      attr_reader :coordinate
+    def face
+      @face ||= Face.for_face_symbol(@native.face)
     end
+
+    attr_reader :coordinate
+  end
 end