twisty_puzzles 0.0.1 → 0.0.2

data/lib/twisty_puzzles/skewb_move_parser.rb

@@ -8,66 +8,65 @@ require 'twisty_puzzles/skewb_move'
 require 'twisty_puzzles/skewb_notation'
 
 module TwistyPuzzles
-  
-    # Parser for Skewb moves.
-    class SkewbMoveParser < AbstractMoveParser
-      MOVE_TYPE_CREATORS = [
-        MoveTypeCreator.new(%i[axis_face cube_direction], Rotation),
-        MoveTypeCreator.new(%i[axis_corner skewb_direction], SkewbMove)
-      ].freeze
+  # Parser for Skewb moves.
+  class SkewbMoveParser < AbstractMoveParser
+    MOVE_TYPE_CREATORS = [
+      MoveTypeCreator.new(%i[axis_face cube_direction], Rotation),
+      MoveTypeCreator.new(%i[axis_corner skewb_direction], SkewbMove)
+    ].freeze
 
-      def initialize(notation)
-        raise TypeError unless notation.is_a?(SkewbNotation)
+    def initialize(notation)
+      raise TypeError unless notation.is_a?(SkewbNotation)
 
-        @notation = notation
-      end
+      @notation = notation
+    end
 
-      FIXED_CORNER_INSTANCE = SkewbMoveParser.new(SkewbNotation.fixed_corner)
-      SARAH_INSTANCE = SkewbMoveParser.new(SkewbNotation.sarah)
-      RUBIKS_INSTANCE = SkewbMoveParser.new(SkewbNotation.rubiks)
+    FIXED_CORNER_INSTANCE = SkewbMoveParser.new(SkewbNotation.fixed_corner)
+    SARAH_INSTANCE = SkewbMoveParser.new(SkewbNotation.sarah)
+    RUBIKS_INSTANCE = SkewbMoveParser.new(SkewbNotation.rubiks)
 
-      def regexp
-        @regexp ||=
-          begin
-            skewb_direction_names =
-              AbstractDirection::POSSIBLE_SKEWB_DIRECTION_NAMES.flatten
-            move_part = "(?:(?<skewb_move>[#{@notation.move_strings.join}])" \
-                        "(?<skewb_direction>[#{skewb_direction_names.join}]?))"
-            rotation_direction_names =
-              AbstractDirection::POSSIBLE_DIRECTION_NAMES.flatten
-            rotation_direction_names.sort_by! { |e| -e.length }
-            rotation_part = "(?:(?<axis_name>[#{AbstractMove::AXES.join}])" \
-                            "(?<cube_direction>#{rotation_direction_names.join('|')}))"
-            Regexp.new("#{move_part}|#{rotation_part}")
-          end
-      end
+    def regexp
+      @regexp ||=
+        begin
+          skewb_direction_names =
+            AbstractDirection::POSSIBLE_SKEWB_DIRECTION_NAMES.flatten
+          move_part = "(?:(?<skewb_move>[#{@notation.move_strings.join}])" \
+                      "(?<skewb_direction>[#{skewb_direction_names.join}]?))"
+          rotation_direction_names =
+            AbstractDirection::POSSIBLE_DIRECTION_NAMES.flatten
+          rotation_direction_names.sort_by! { |e| -e.length }
+          rotation_part = "(?:(?<axis_name>[#{AbstractMove::AXES.join}])" \
+                          "(?<cube_direction>#{rotation_direction_names.join('|')}))"
+          Regexp.new("#{move_part}|#{rotation_part}")
+        end
+    end
 
-      def move_type_creators
-        MOVE_TYPE_CREATORS
-      end
+    def move_type_creators
+      MOVE_TYPE_CREATORS
+    end
 
-      def parse_skewb_direction(direction_string)
-        if AbstractDirection::POSSIBLE_DIRECTION_NAMES[0].include?(direction_string)
-          SkewbDirection::FORWARD
-        elsif AbstractDirection::POSSIBLE_DIRECTION_NAMES[-1].include?(direction_string)
-          SkewbDirection::BACKWARD
-        else
-          raise ArgumentError
-        end
+    def parse_skewb_direction(direction_string)
+      if AbstractDirection::POSSIBLE_DIRECTION_NAMES[0].include?(direction_string)
+        SkewbDirection::FORWARD
+      elsif AbstractDirection::POSSIBLE_DIRECTION_NAMES[-1].include?(direction_string)
+        SkewbDirection::BACKWARD
+      else
+        raise ArgumentError
       end
+    end
 
-      def parse_part_key(name)
-        name.sub('name', 'face').sub('skewb_move', 'axis_corner')
-      end
+    def parse_part_key(name)
+      name.sub('name', 'face').sub('skewb_move', 'axis_corner')
+    end
 
-      def parse_move_part(name, value)
-        case name
-        when 'axis_name' then CubeMoveParser::INSTANCE.parse_axis_face(value)
-        when 'cube_direction' then CubeMoveParser::INSTANCE.parse_direction(value)
-        when 'skewb_move' then @notation.corner(value)
-        when 'skewb_direction' then parse_skewb_direction(value)
-        else raise
-        end
+    def parse_move_part(name, value)
+      case name
+      when 'axis_name' then CubeMoveParser::INSTANCE.parse_axis_face(value)
+      when 'cube_direction' then CubeMoveParser::INSTANCE.parse_direction(value)
+      when 'skewb_move' then @notation.corner(value)
+      when 'skewb_direction' then parse_skewb_direction(value)
+      else raise
       end
     end
+  end
 end

data/lib/twisty_puzzles/skewb_notation.rb

@@ -7,141 +7,138 @@ require 'twisty_puzzles/skewb_direction'
 require 'twisty_puzzles/skewb_move'
 
 module TwistyPuzzles
-  
-    # Class that represents one notation for Skewb moves, e.g. Sarahs notation or fixed
-    # corner notation.
-    class SkewbNotation
-      def initialize(name, move_corner_pairs)
-        raise TypeError unless name.is_a?(String)
-
-        check_move_corner_pairs(move_corner_pairs)
-        @name = name
-        @move_to_corner = move_corner_pairs.to_h.freeze
-        @corner_to_move = move_corner_pairs.collect_concat do |m, c|
-          c.rotations.map { |e| [e, m] }
-        end.to_h.freeze
-        @move_strings = move_corner_pairs.map(&:first).freeze
-        @non_zero_moves =
-          move_corner_pairs.map(&:last).product(SkewbDirection::NON_ZERO_DIRECTIONS).map do |c, d|
-            SkewbMove.new(c, d)
-          end.freeze
-        freeze
-      end
-
-      def check_move_corner_pairs(move_corner_pairs)
-        move_corner_pairs.each do |m|
-          raise ArgumentError unless m.length == 2
-          raise TypeError unless m[0].is_a?(String)
-          raise TypeError unless m[1].is_a?(Corner)
-        end
-        if move_corner_pairs.map(&:first).uniq.length != move_corner_pairs.length
-          raise ArgumentError
-        end
+  # Class that represents one notation for Skewb moves, e.g. Sarahs notation or fixed
+  # corner notation.
+  class SkewbNotation
+    def initialize(name, move_corner_pairs)
+      raise TypeError unless name.is_a?(String)
+
+      check_move_corner_pairs(move_corner_pairs)
+      @name = name
+      @move_to_corner = move_corner_pairs.to_h.freeze
+      @corner_to_move = move_corner_pairs.collect_concat do |m, c|
+        c.rotations.map { |e| [e, m] }
+      end.to_h.freeze
+      @move_strings = move_corner_pairs.map(&:first).freeze
+      @non_zero_moves =
+        move_corner_pairs.map(&:last).product(SkewbDirection::NON_ZERO_DIRECTIONS).map do |c, d|
+          SkewbMove.new(c, d)
+        end.freeze
+      freeze
+    end
 
-        check_corner_coverage(move_corner_pairs.map(&:last))
+    def check_move_corner_pairs(move_corner_pairs)
+      move_corner_pairs.each do |m|
+        raise ArgumentError unless m.length == 2
+        raise TypeError unless m[0].is_a?(String)
+        raise TypeError unless m[1].is_a?(Corner)
       end
+      raise ArgumentError if move_corner_pairs.map(&:first).uniq.length != move_corner_pairs.length
+
+      check_corner_coverage(move_corner_pairs.map(&:last))
+    end
 
-      def check_corner_coverage(corners)
-        corner_closure = corners + corners.map(&:diagonal_opposite)
-        Corner::ELEMENTS.each do |corner|
-          unless corner_closure.any? { |c| c.turned_equals?(corner) }
-            raise ArgumentError,
-                  "Turns around corner #{corner} cannot be represented in notation #{name}."
-          end
+    def check_corner_coverage(corners)
+      corner_closure = corners + corners.map(&:diagonal_opposite)
+      Corner::ELEMENTS.each do |corner|
+        unless corner_closure.any? { |c| c.turned_equals?(corner) }
+          raise ArgumentError,
+                "Turns around corner #{corner} cannot be represented in notation #{name}."
         end
       end
+    end
 
-      attr_reader :name, :move_strings, :non_zero_moves
-      private_class_method :new
-
-      def self.fixed_corner
-        @fixed_corner ||= new(
-          'fixed corner', [
-            ['U', Corner.for_face_symbols(%i[U L B])],
-            ['R', Corner.for_face_symbols(%i[D R B])],
-            ['L', Corner.for_face_symbols(%i[D F L])],
-            ['B', Corner.for_face_symbols(%i[D B L])]
-          ]
-        )
-      end
+    attr_reader :name, :move_strings, :non_zero_moves
+    private_class_method :new
+
+    def self.fixed_corner
+      @fixed_corner ||= new(
+        'fixed corner', [
+          ['U', Corner.for_face_symbols(%i[U L B])],
+          ['R', Corner.for_face_symbols(%i[D R B])],
+          ['L', Corner.for_face_symbols(%i[D F L])],
+          ['B', Corner.for_face_symbols(%i[D B L])]
+        ]
+      )
+    end
 
-      def self.sarah
-        @sarah ||= new(
-          'sarah', [
-            ['F', Corner.for_face_symbols(%i[U R F])],
-            ['R', Corner.for_face_symbols(%i[U B R])],
-            ['B', Corner.for_face_symbols(%i[U L B])],
-            ['L', Corner.for_face_symbols(%i[U F L])]
-          ]
-        )
-      end
+    def self.sarah
+      @sarah ||= new(
+        'sarah', [
+          ['F', Corner.for_face_symbols(%i[U R F])],
+          ['R', Corner.for_face_symbols(%i[U B R])],
+          ['B', Corner.for_face_symbols(%i[U L B])],
+          ['L', Corner.for_face_symbols(%i[U F L])]
+        ]
+      )
+    end
 
-      def self.rubiks
-        @rubiks ||= new(
-          'rubiks', [
-            ['F', Corner.for_face_symbols(%i[U R F])],
-            ['R', Corner.for_face_symbols(%i[U B R])],
-            ['B', Corner.for_face_symbols(%i[U L B])],
-            ['L', Corner.for_face_symbols(%i[U F L])],
-            ['f', Corner.for_face_symbols(%i[D F R])],
-            ['r', Corner.for_face_symbols(%i[D R B])],
-            ['b', Corner.for_face_symbols(%i[D B L])],
-            ['l', Corner.for_face_symbols(%i[D L F])]
-          ]
-        )
-      end
+    def self.rubiks
+      @rubiks ||= new(
+        'rubiks', [
+          ['F', Corner.for_face_symbols(%i[U R F])],
+          ['R', Corner.for_face_symbols(%i[U B R])],
+          ['B', Corner.for_face_symbols(%i[U L B])],
+          ['L', Corner.for_face_symbols(%i[U F L])],
+          ['f', Corner.for_face_symbols(%i[D F R])],
+          ['r', Corner.for_face_symbols(%i[D R B])],
+          ['b', Corner.for_face_symbols(%i[D B L])],
+          ['l', Corner.for_face_symbols(%i[D L F])]
+        ]
+      )
+    end
 
-      def to_s
-        @name
-      end
+    def to_s
+      @name
+    end
 
-      def corner(move)
-        @move_to_corner[move] || (raise ArgumentError)
-      end
+    def corner(move)
+      @move_to_corner[move] || (raise ArgumentError)
+    end
 
-      def algorithm_to_string(algorithm)
-        reversed_rotations = []
-        num_tail_rotations = CancellationHelper.num_tail_rotations(algorithm)
-        alg_string = algorithm.moves[0...algorithm.length - num_tail_rotations].map do |m|
-          move_to_string(m, reversed_rotations)
-        end.join(' ')
-        new_tail_rotations = reversed_rotations.reverse! +
-                             algorithm.moves[algorithm.length - num_tail_rotations..-1]
-        cancelled_rotations = Algorithm.new(new_tail_rotations).cancelled(3)
-        cancelled_rotations.empty? ? alg_string : "#{alg_string} #{cancelled_rotations}"
-      end
+    def algorithm_to_string(algorithm)
+      reversed_rotations = []
+      num_tail_rotations = CancellationHelper.num_tail_rotations(algorithm)
+      alg_string = algorithm.moves[0...algorithm.length - num_tail_rotations].map do |m|
+        move_to_string(m, reversed_rotations)
+      end.join(' ')
+      new_tail_rotations = reversed_rotations.reverse! +
+                           algorithm.moves[algorithm.length - num_tail_rotations..-1]
+      cancelled_rotations = Algorithm.new(new_tail_rotations).cancelled(3)
+      cancelled_rotations.empty? ? alg_string : "#{alg_string} #{cancelled_rotations}"
+    end
 
-      private
+    private
 
-      def move_to_string(move, reversed_rotations)
-        reversed_rotations.each { |r| move = move.rotate_by(r.inverse) }
-        case move
-        when SkewbMove then skewb_move_to_string(move, reversed_rotations)
-        when Rotation then move.to_s
-        else raise ArgumentError, "Couldn't transform #{move} to #{@name} Skewb notation."
-        end
+    def move_to_string(move, reversed_rotations)
+      reversed_rotations.each { |r| move = move.rotate_by(r.inverse) }
+      case move
+      when SkewbMove then skewb_move_to_string(move, reversed_rotations)
+      when Rotation then move.to_s
+      else raise ArgumentError, "Couldn't transform #{move} to #{@name} Skewb notation."
       end
+    end
 
-      def skewb_move_to_string(move, reversed_rotations)
-        move_string, rotate = move_to_string_internal(move)
-        if rotate
-          reversed_additional_rotations =
-            Rotation.around_corner(move.axis_corner, move.direction).moves.reverse
-          reversed_rotations.concat(reversed_additional_rotations)
-        end
-        "#{move_string}#{move.direction.name}"
+    def skewb_move_to_string(move, reversed_rotations)
+      move_string, rotate = move_to_string_internal(move)
+      if rotate
+        reversed_additional_rotations =
+          Rotation.around_corner(move.axis_corner, move.direction).moves.reverse
+        reversed_rotations.concat(reversed_additional_rotations)
       end
+      "#{move_string}#{move.direction.name}"
+    end
 
-      # Returns the move string of the given move and true if a rotation has to be done to correct
-      # for the fact that we actually used the opposite corner.
-      def move_to_string_internal(move)
-        if (move_string = @corner_to_move[move.axis_corner])
-          [move_string, false]
-        elsif (move_string = @corner_to_move[move.axis_corner.diagonal_opposite])
-          [move_string, !move.direction.zero?]
-        else
-          raise
-        end
+    # Returns the move string of the given move and true if a rotation has to be done to correct
+    # for the fact that we actually used the opposite corner.
+    def move_to_string_internal(move)
+      if (move_string = @corner_to_move[move.axis_corner])
+        [move_string, false]
+      elsif (move_string = @corner_to_move[move.axis_corner.diagonal_opposite])
+        [move_string, !move.direction.zero?]
+      else
+        raise
       end
     end
+  end
 end

data/lib/twisty_puzzles/skewb_state.rb

@@ -7,157 +7,156 @@ require 'twisty_puzzles/state_helper'
 require 'twisty_puzzles/cube_constants'
 
 module TwistyPuzzles
-  
-    # Represents the state (i.e. the sticker positions) of a Skewb.
-    class SkewbState
-      include CubePrintHelper
-      include StateHelper
-      include CubeConstants
-      # Pairs of coordinate pairs that should match in case of solved layers.
-      MATCHING_CORNERS =
-        begin
-          matching_corners = []
-          Corner::ELEMENTS.each do |c1|
-            Corner::ELEMENTS.each do |c2|
-              # Take corner pairs that have a common edge.
-              next unless c1.common_edge_with?(c2)
-
-              check_parts = []
-              c1.rotations.each do |c1_rot|
-                next unless c2.face_symbols.include?(c1_rot.face_symbols.first)
-
-                c2_rot = c2.rotate_face_symbol_up(c1_rot.face_symbols.first)
-                check_parts.push([
-                                   SkewbCoordinate.for_corner(c1_rot),
-                                   SkewbCoordinate.for_corner(c2_rot)
-                                 ])
-              end
-              matching_corners.push(check_parts)
+  # Represents the state (i.e. the sticker positions) of a Skewb.
+  class SkewbState
+    include CubePrintHelper
+    include StateHelper
+    include CubeConstants
+    # Pairs of coordinate pairs that should match in case of solved layers.
+    MATCHING_CORNERS =
+      begin
+        matching_corners = []
+        Corner::ELEMENTS.each do |c1|
+          Corner::ELEMENTS.each do |c2|
+            # Take corner pairs that have a common edge.
+            next unless c1.common_edge_with?(c2)
+
+            check_parts = []
+            c1.rotations.each do |c1_rot|
+              next unless c2.face_symbols.include?(c1_rot.face_symbols.first)
+
+              c2_rot = c2.rotate_face_symbol_up(c1_rot.face_symbols.first)
+              check_parts.push([
+                                 SkewbCoordinate.for_corner(c1_rot),
+                                 SkewbCoordinate.for_corner(c2_rot)
+                               ])
             end
+            matching_corners.push(check_parts)
           end
-          matching_corners.uniq
         end
-      # Pairs of stickers that can be used to check whether the "outside" of a layer on the given
-      # face is a proper layer.
-      LAYER_CHECK_NEIGHBORS =
-        begin
-          layer_check_neighbors = {}
-          MATCHING_CORNERS.each do |a, b|
-            [[a.first.face, b], [b.first.face, a]].each do |face, coordinates|
-              # We take the first one we encounter, but it doesn't matter, we could take any.
-              layer_check_neighbors[face] ||= coordinates
-            end
+        matching_corners.uniq
+      end
+    # Pairs of stickers that can be used to check whether the "outside" of a layer on the given
+    # face is a proper layer.
+    LAYER_CHECK_NEIGHBORS =
+      begin
+        layer_check_neighbors = {}
+        MATCHING_CORNERS.each do |a, b|
+          [[a.first.face, b], [b.first.face, a]].each do |face, coordinates|
+            # We take the first one we encounter, but it doesn't matter, we could take any.
+            layer_check_neighbors[face] ||= coordinates
           end
-          layer_check_neighbors
         end
+        layer_check_neighbors
+      end
 
-      def initialize(native)
-        raise TypeError unless native.is_a?(Native::SkewbState)
+    def initialize(native)
+      raise TypeError unless native.is_a?(Native::SkewbState)
 
-        @native = native
-      end
+      @native = native
+    end
 
-      attr_reader :native
+    attr_reader :native
 
-      def self.for_solved_colors(solved_colors)
-        native = Native::SkewbState.new(solved_colors)
-        new(native)
-      end
+    def self.for_solved_colors(solved_colors)
+      native = Native::SkewbState.new(solved_colors)
+      new(native)
+    end
 
-      def eql?(other)
-        self.class.equal?(other.class) && @native == other.native
-      end
+    def eql?(other)
+      self.class.equal?(other.class) && @native == other.native
+    end
 
-      alias == eql?
+    alias == eql?
 
-      def hash
-        @hash ||= [self.class, @native].hash
-      end
+    def hash
+      @hash ||= [self.class, @native].hash
+    end
 
-      # TODO: Get rid of this backwards compatibility artifact
-      def sticker_array(face)
-        raise TypeError unless face.is_a?(Face)
+    # TODO: Get rid of this backwards compatibility artifact
+    def sticker_array(face)
+      raise TypeError unless face.is_a?(Face)
 
-        center_sticker = self[SkewbCoordinate.for_center(face)]
-        corner_stickers =
-          face.clockwise_corners.sort.map do |c|
-            self[SkewbCoordinate.for_corner(c)]
-          end
-        [center_sticker] + corner_stickers
-      end
+      center_sticker = self[SkewbCoordinate.for_center(face)]
+      corner_stickers =
+        face.clockwise_corners.sort.map do |c|
+          self[SkewbCoordinate.for_corner(c)]
+        end
+      [center_sticker] + corner_stickers
+    end
 
-      def dup
-        SkewbState.new(@native.dup)
-      end
+    def dup
+      SkewbState.new(@native.dup)
+    end
 
-      def to_s
-        skewb_string(self, :nocolor)
-      end
+    def to_s
+      skewb_string(self, :nocolor)
+    end
 
-      def colored_to_s
-        skewb_string(self, :color)
-      end
+    def colored_to_s
+      skewb_string(self, :color)
+    end
 
-      def apply_move(move)
-        move.apply_to(self)
-      end
+    def apply_move(move)
+      move.apply_to(self)
+    end
 
-      def apply_algorithm(alg)
-        alg.apply_to(self)
-      end
+    def apply_algorithm(alg)
+      alg.apply_to(self)
+    end
 
-      def apply_rotation(rot)
-        rot.apply_to_skewb(self)
-      end
+    def apply_rotation(rot)
+      rot.apply_to_skewb(self)
+    end
 
-      def [](coordinate)
-        @native[coordinate.native]
-      end
+    def [](coordinate)
+      @native[coordinate.native]
+    end
 
-      def []=(coordinate, color)
-        @native[coordinate.native] = color
-        sticker_array(coordinate.face)[coordinate.coordinate] = color
-      end
+    def []=(coordinate, color)
+      @native[coordinate.native] = color
+      sticker_array(coordinate.face)[coordinate.coordinate] = color
+    end
 
-      def any_layer_solved?
-        !solved_layers.empty?
-      end
+    def any_layer_solved?
+      !solved_layers.empty?
+    end
 
-      # Returns the color of all solved layers. Empty if there is none.
-      def solved_layers
-        solved_faces = Face::ELEMENTS.select { |f| layer_at_face_solved?(f) }
-        solved_faces.map { |f| self[SkewbCoordinate.for_center(f)] }
-      end
+    # Returns the color of all solved layers. Empty if there is none.
+    def solved_layers
+      solved_faces = Face::ELEMENTS.select { |f| layer_at_face_solved?(f) }
+      solved_faces.map { |f| self[SkewbCoordinate.for_center(f)] }
+    end
 
-      def layer_solved?(color)
-        Face::ELEMENTS.any? do |f|
-          self[SkewbCoordinate.for_center(f)] == color && layer_at_face_solved?(f)
-        end
+    def layer_solved?(color)
+      Face::ELEMENTS.any? do |f|
+        self[SkewbCoordinate.for_center(f)] == color && layer_at_face_solved?(f)
       end
+    end
 
-      def center_face(color)
-        Face::ELEMENTS.find { |f| self[SkewbCoordinate.for_center(f)] == color }
-      end
+    def center_face(color)
+      Face::ELEMENTS.find { |f| self[SkewbCoordinate.for_center(f)] == color }
+    end
 
-      def layer_check_neighbors(face)
-        LAYER_CHECK_NEIGHBORS[face]
-      end
+    def layer_check_neighbors(face)
+      LAYER_CHECK_NEIGHBORS[face]
+    end
 
-      # Note that this does NOT say that the layer corresponding to the given face is solved.
-      # The face argument is used as the position where a solved face is present.
-      def layer_at_face_solved?(face)
-        return false unless native.face_solved?(face.face_symbol)
+    # Note that this does NOT say that the layer corresponding to the given face is solved.
+    # The face argument is used as the position where a solved face is present.
+    def layer_at_face_solved?(face)
+      return false unless native.face_solved?(face.face_symbol)
 
-        layer_check_neighbors(face).map { |c| self[c] }.uniq.length == 1
-      end
+      layer_check_neighbors(face).map { |c| self[c] }.uniq.length == 1
+    end
 
-      def rotate_face(face, direction)
-        neighbors = face.neighbors
-        inverse_order_face = face.coordinate_index_close_to(neighbors[0]) <
-                             face.coordinate_index_close_to(neighbors[1])
-        direction = direction.inverse if inverse_order_face
-        cycle = SkewbCoordinate.corners_on_face(face)
-        apply_4sticker_cycle(cycle, direction)
-      end
+    def rotate_face(face, direction)
+      neighbors = face.neighbors
+      inverse_order_face = face.coordinate_index_close_to(neighbors[0]) <
+                           face.coordinate_index_close_to(neighbors[1])
+      direction = direction.inverse if inverse_order_face
+      cycle = SkewbCoordinate.corners_on_face(face)
+      apply_4sticker_cycle(cycle, direction)
     end
+  end
 end