twisty_puzzles 0.0.1 → 0.0.2

data/lib/twisty_puzzles/part_cycle_factory.rb

@@ -4,56 +4,53 @@ require 'twisty_puzzles/sticker_cycle'
 require 'twisty_puzzles/utils/array_helper'
 
 module TwistyPuzzles
-  
-    # Factory for sticker cycles given part cycles.
-    class PartCycleFactory
-      include Utils::ArrayHelper
-
-      def initialize(cube_size, incarnation_index)
-        CubeState.check_cube_size(cube_size)
-        unless incarnation_index.is_a?(Integer) && incarnation_index >= 0
-          raise ArgumentError, "Invalid incarnation index #{incarnation_index}."
-        end
-
-        @cube_size = cube_size
-        @incarnation_index = incarnation_index
-        @cache = {}
+  # Factory for sticker cycles given part cycles.
+  class PartCycleFactory
+    include Utils::ArrayHelper
+
+    def initialize(cube_size, incarnation_index)
+      CubeState.check_cube_size(cube_size)
+      unless incarnation_index.is_a?(Integer) && incarnation_index >= 0
+        raise ArgumentError, "Invalid incarnation index #{incarnation_index}."
       end
 
-      def coordinates(part)
-        @cache[part] ||= Coordinate.solved_positions(part, @cube_size, @incarnation_index)
-      end
+      @cube_size = cube_size
+      @incarnation_index = incarnation_index
+      @cache = {}
+    end
 
-      def multi_twist(parts)
-        unless parts.all? { |p| p.is_a?(Corner) || p.is_a?(Edge) }
-          raise TypeError, 'Twists are only supported for edges and corners.'
-        end
+    def coordinates(part)
+      @cache[part] ||= Coordinate.solved_positions(part, @cube_size, @incarnation_index)
+    end
 
-        cycles = parts.map { |p| StickerCycle.new(@cube_size, coordinates(p)) }
-        StickerCycles.new(@cube_size, cycles)
+    def multi_twist(parts)
+      unless parts.all? { |p| p.is_a?(Corner) || p.is_a?(Edge) }
+        raise TypeError, 'Twists are only supported for edges and corners.'
       end
 
-      def check_type_consistency(parts)
-        return unless parts.any? { |p| p.class != parts.first.class }
+      cycles = parts.map { |p| StickerCycle.new(@cube_size, coordinates(p)) }
+      StickerCycles.new(@cube_size, cycles)
+    end
 
-        raise TypeError, "Cycles of heterogenous piece types #{parts.inspect} are not supported."
-      end
+    def check_type_consistency(parts)
+      return unless parts.any? { |p| p.class != parts.first.class }
 
-      def construct(parts)
-        if parts.length < 2
-          raise ArgumentError, 'Cycles of length smaller than 2 are not supported.'
-        end
-
-        unless @incarnation_index < parts.first.num_incarnations(@cube_size)
-          raise ArgumentError, "Incarnation index #{@incarnation_index} for cube size " \
-                               "#{@cube_size} is not supported for #{parts.first.inspect}."
-        end
-
-        check_types(parts, Part)
-        check_type_consistency(parts)
-        part_coordinates = parts.map { |p| coordinates(p) }
-        cycles = part_coordinates.transpose.map { |c| StickerCycle.new(@cube_size, c) }
-        StickerCycles.new(@cube_size, cycles)
+      raise TypeError, "Cycles of heterogenous piece types #{parts.inspect} are not supported."
+    end
+
+    def construct(parts)
+      raise ArgumentError, 'Cycles of length smaller than 2 are not supported.' if parts.length < 2
+
+      unless @incarnation_index < parts.first.num_incarnations(@cube_size)
+        raise ArgumentError, "Incarnation index #{@incarnation_index} for cube size " \
+                             "#{@cube_size} is not supported for #{parts.first.inspect}."
       end
+
+      check_types(parts, Part)
+      check_type_consistency(parts)
+      part_coordinates = parts.map { |p| coordinates(p) }
+      cycles = part_coordinates.transpose.map { |c| StickerCycle.new(@cube_size, c) }
+      StickerCycles.new(@cube_size, cycles)
     end
+  end
 end

data/lib/twisty_puzzles/puzzle.rb

@@ -1,26 +1,25 @@
 # frozen_string_literal: true
 
 module TwistyPuzzles
-  
-    # Represents one type of puzzle.
-    class Puzzle
-      def initialize(name)
-        @name = name
-      end
-
-      NXN_CUBE = Puzzle.new('nxn cube')
-      SKEWB = Puzzle.new('skewb')
+  # Represents one type of puzzle.
+  class Puzzle
+    def initialize(name)
+      @name = name
+    end
 
-      attr_reader :name
+    NXN_CUBE = Puzzle.new('nxn cube')
+    SKEWB = Puzzle.new('skewb')
 
-      def eql?(other)
-        self.class == other.class && name == other.name
-      end
+    attr_reader :name
 
-      def hash
-        @hash ||= [self.class, @name].hash
-      end
+    def eql?(other)
+      self.class == other.class && name == other.name
+    end
 
-      alias == eql?
+    def hash
+      @hash ||= [self.class, @name].hash
     end
+
+    alias == eql?
+  end
 end

data/lib/twisty_puzzles/reversible_applyable.rb

@@ -3,35 +3,34 @@
 require 'twisty_puzzles/skewb_state'
 
 module TwistyPuzzles
-  
-    # Module that makes a class that has an `apply_to` and `reverse` be able to apply temporarily.
-    module ReversibleApplyable
-      def apply_to_dupped(puzzle_state)
-        dupped = puzzle_state.dup
-        apply_to(dupped)
-        dupped
-      end
+  # Module that makes a class that has an `apply_to` and `reverse` be able to apply temporarily.
+  module ReversibleApplyable
+    def apply_to_dupped(puzzle_state)
+      dupped = puzzle_state.dup
+      apply_to(dupped)
+      dupped
+    end
 
-      # Applies the current algorithm/cycle/whatever to the given puzzle state and yields the
-      # modified version. The puzzle state will be the same as the original after this function
-      # returns.
-      # Whether the yielded puzzle state is actually the same as the passed one or a copy is an
-      # implementation detail.
-      def apply_temporarily_to(puzzle_state)
-        return yield(apply_to_dupped(puzzle_state)) if with_dup_is_faster?(puzzle_state)
+    # Applies the current algorithm/cycle/whatever to the given puzzle state and yields the
+    # modified version. The puzzle state will be the same as the original after this function
+    # returns.
+    # Whether the yielded puzzle state is actually the same as the passed one or a copy is an
+    # implementation detail.
+    def apply_temporarily_to(puzzle_state)
+      return yield(apply_to_dupped(puzzle_state)) if with_dup_is_faster?(puzzle_state)
 
-        apply_to(puzzle_state)
-        begin
-          yield(puzzle_state)
-        ensure
-          inverse.apply_to(puzzle_state)
-        end
+      apply_to(puzzle_state)
+      begin
+        yield(puzzle_state)
+      ensure
+        inverse.apply_to(puzzle_state)
       end
+    end
 
-      private
+    private
 
-      def with_dup_is_faster?(state)
-        !state.is_a?(CubeState) || state.n <= 4
-      end
+    def with_dup_is_faster?(state)
+      !state.is_a?(CubeState) || state.n <= 4
     end
+  end
 end

data/lib/twisty_puzzles/rotation.rb

@@ -8,98 +8,97 @@ require 'twisty_puzzles/cube_move'
 require 'twisty_puzzles/puzzle'
 
 module TwistyPuzzles
-  
-    # A rotation of a Skewb or cube.
-    class Rotation < AxisFaceAndDirectionMove
-      ALL_ROTATIONS = Face::ELEMENTS.product(CubeDirection::ALL_DIRECTIONS).map { |f, d| new(f, d) }
-      NON_ZERO_ROTATIONS =
-        Face::ELEMENTS.product(CubeDirection::NON_ZERO_DIRECTIONS).map { |f, d| new(f, d) }
-      LEFT = new(Face::U, CubeDirection::BACKWARD)
-      RIGHT = new(Face::U, CubeDirection::FORWARD)
-
-      # Translates a Skewb direction into a cube direction.
-      def self.translated_direction(direction)
-        case direction
-        when SkewbDirection::ZERO then CubeDirection::ZERO
-        when SkewbDirection::FORWARD then CubeDirection::FORWARD
-        when SkewbDirection::BACKWARD then CubeDirection::BACKWARD
-        end
+  # A rotation of a Skewb or cube.
+  class Rotation < AxisFaceAndDirectionMove
+    ALL_ROTATIONS = Face::ELEMENTS.product(CubeDirection::ALL_DIRECTIONS).map { |f, d| new(f, d) }
+    NON_ZERO_ROTATIONS =
+      Face::ELEMENTS.product(CubeDirection::NON_ZERO_DIRECTIONS).map { |f, d| new(f, d) }
+    LEFT = new(Face::U, CubeDirection::BACKWARD)
+    RIGHT = new(Face::U, CubeDirection::FORWARD)
+
+    # Translates a Skewb direction into a cube direction.
+    def self.translated_direction(direction)
+      case direction
+      when SkewbDirection::ZERO then CubeDirection::ZERO
+      when SkewbDirection::FORWARD then CubeDirection::FORWARD
+      when SkewbDirection::BACKWARD then CubeDirection::BACKWARD
       end
+    end
 
-      # Returns an algorithm consisting of two rotations that are equivalent to rotating
-      # the puzzle around a corner.
-      # Takes a Skewb direction as an argument (even for cubes) because rotating around
-      # is like a Skewb move given that it's modulo 3.
-      def self.around_corner(corner, skewb_direction)
-        raise TypeError unless corner.is_a?(Corner)
-        raise TypeError unless skewb_direction.is_a?(SkewbDirection)
+    # Returns an algorithm consisting of two rotations that are equivalent to rotating
+    # the puzzle around a corner.
+    # Takes a Skewb direction as an argument (even for cubes) because rotating around
+    # is like a Skewb move given that it's modulo 3.
+    def self.around_corner(corner, skewb_direction)
+      raise TypeError unless corner.is_a?(Corner)
+      raise TypeError unless skewb_direction.is_a?(SkewbDirection)
 
-        direction = translated_direction(skewb_direction)
+      direction = translated_direction(skewb_direction)
 
-        Algorithm.new([
-                        Rotation.new(corner.faces[skewb_direction.value], direction),
-                        Rotation.new(corner.faces[0], direction)
-                      ])
-      end
+      Algorithm.new([
+                      Rotation.new(corner.faces[skewb_direction.value], direction),
+                      Rotation.new(corner.faces[0], direction)
+                    ])
+    end
 
-      def to_s
-        "#{AXES[@axis_face.axis_priority]}#{canonical_direction.name}"
-      end
+    def to_s
+      "#{AXES[@axis_face.axis_priority]}#{canonical_direction.name}"
+    end
 
-      def puzzles
-        [Puzzle::SKEWB, Puzzle::NXN_CUBE]
-      end
+    def puzzles
+      [Puzzle::SKEWB, Puzzle::NXN_CUBE]
+    end
 
-      def slice_move?
-        false
-      end
+    def slice_move?
+      false
+    end
 
-      # Returns an alternative representation of the same rotation
-      def alternative
-        Rotation.new(@axis_face.opposite, @direction.inverse)
-      end
+    # Returns an alternative representation of the same rotation
+    def alternative
+      Rotation.new(@axis_face.opposite, @direction.inverse)
+    end
 
-      def equivalent_internal?(other, _cube_size)
-        [self, alternative].include?(other)
-      end
+    def equivalent_internal?(other, _cube_size)
+      [self, alternative].include?(other)
+    end
 
-      def prepend_rotation(other, _cube_size)
-        if same_axis?(other)
-          direction = translated_direction(other.axis_face)
-          Algorithm.move(Rotation.new(other.axis_face, direction + other.direction))
-        elsif @direction.double_move? && other.direction.double_move?
-          used_axis_priorities = [@axis_face, other.axis_face].map(&:axis_priority)
-          # Note that there are two solutions, but any works.
-          remaining_face =
-            Face::ELEMENTS.find { |f| !used_axis_priorities.include?(f.axis_priority) }
-          Algorithm.move(Rotation.new(remaining_face, CubeDirection::DOUBLE))
-        end
+    def prepend_rotation(other, _cube_size)
+      if same_axis?(other)
+        direction = translated_direction(other.axis_face)
+        Algorithm.move(Rotation.new(other.axis_face, direction + other.direction))
+      elsif @direction.double_move? && other.direction.double_move?
+        used_axis_priorities = [@axis_face, other.axis_face].map(&:axis_priority)
+        # Note that there are two solutions, but any works.
+        remaining_face =
+          Face::ELEMENTS.find { |f| !used_axis_priorities.include?(f.axis_priority) }
+        Algorithm.move(Rotation.new(remaining_face, CubeDirection::DOUBLE))
       end
+    end
 
-      def prepend_fat_m_slice_move(_other, _cube_size)
-        nil
-      end
+    def prepend_fat_m_slice_move(_other, _cube_size)
+      nil
+    end
 
-      def prepend_fat_move(other, cube_size)
-        return unless compatible_fat_move?(other)
+    def prepend_fat_move(other, cube_size)
+      return unless compatible_fat_move?(other)
 
-        Algorithm.move(
-          FatMove.new(other.axis_face.opposite, other.direction, other.inverted_width(cube_size))
-        )
-      end
+      Algorithm.move(
+        FatMove.new(other.axis_face.opposite, other.direction, other.inverted_width(cube_size))
+      )
+    end
 
-      def prepend_slice_move(_other, _cube_size)
-        nil
-      end
+    def prepend_slice_move(_other, _cube_size)
+      nil
+    end
 
-      def move_count(_cube_size, _metric = :htm)
-        0
-      end
+    def move_count(_cube_size, _metric = :htm)
+      0
+    end
 
-      private
+    private
 
-      def compatible_fat_move?(other)
-        same_axis?(other) && translated_direction(other.axis_face) == other.direction.inverse
-      end
+    def compatible_fat_move?(other)
+      same_axis?(other) && translated_direction(other.axis_face) == other.direction.inverse
     end
+  end
 end

data/lib/twisty_puzzles/skewb_direction.rb

@@ -3,22 +3,21 @@
 require 'twisty_puzzles/abstract_direction'
 
 module TwistyPuzzles
-  
-    # Represents the direction of a Skewb move except a rotation.
-    class SkewbDirection < AbstractDirection
-      NUM_DIRECTIONS = 3
-      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)
-      BACKWARD = new(2)
+  # Represents the direction of a Skewb move except a rotation.
+  class SkewbDirection < AbstractDirection
+    NUM_DIRECTIONS = 3
+    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)
+    BACKWARD = new(2)
 
-      def name
-        SIMPLE_SKEWB_DIRECTION_NAMES[@value]
-      end
+    def name
+      SIMPLE_SKEWB_DIRECTION_NAMES[@value]
+    end
 
-      def double_move?
-        false
-      end
+    def double_move?
+      false
     end
+  end
 end

data/lib/twisty_puzzles/skewb_move.rb

@@ -6,54 +6,53 @@ require 'twisty_puzzles/skewb_direction'
 require 'twisty_puzzles/puzzle'
 
 module TwistyPuzzles
-  
-    # Base class for skewb moves.
-    class SkewbMove < AbstractMove
-      def initialize(axis_corner, direction)
-        raise TypeError unless axis_corner.is_a?(Corner)
-        raise TypeError unless direction.is_a?(SkewbDirection)
-
-        @axis_corner = axis_corner.rotate_face_up(axis_corner.faces.min_by(&:piece_index))
-        @direction = direction
-      end
-
-      def puzzles
-        [Puzzle::SKEWB]
-      end
-
-      attr_reader :axis_corner, :direction
-
-      def to_s
-        "#{@axis_corner}#{@direction.name}"
-      end
-
-      def slice_move?
-        false
-      end
-
-      def identifying_fields
-        [@axis_corner, @direction]
-      end
-
-      def rotate_by(rotation)
-        nice_face =
-          find_only(@axis_corner.adjacent_faces) do |f|
-            f.same_axis?(rotation.axis_face)
-          end
-        nice_direction = rotation.translated_direction(nice_face)
-        nice_face_corners = nice_face.clockwise_corners
-        on_nice_face_index = nice_face_corners.index { |c| c.turned_equals?(@axis_corner) }
-        new_corner =
-          nice_face_corners[(on_nice_face_index + nice_direction.value) % nice_face_corners.length]
-        self.class.new(new_corner, @direction)
-      end
-
-      def mirror(normal_face)
-        faces = @axis_corner.adjacent_faces
-        replaced_face = find_only(faces) { |f| f.same_axis?(normal_face) }
-        new_corner =
-          Corner.between_faces(replace_once(faces, replaced_face, replaced_face.opposite))
-        self.class.new(new_corner, @direction.inverse)
-      end
+  # Base class for skewb moves.
+  class SkewbMove < AbstractMove
+    def initialize(axis_corner, direction)
+      raise TypeError unless axis_corner.is_a?(Corner)
+      raise TypeError unless direction.is_a?(SkewbDirection)
+
+      @axis_corner = axis_corner.rotate_face_up(axis_corner.faces.min_by(&:piece_index))
+      @direction = direction
     end
+
+    def puzzles
+      [Puzzle::SKEWB]
+    end
+
+    attr_reader :axis_corner, :direction
+
+    def to_s
+      "#{@axis_corner}#{@direction.name}"
+    end
+
+    def slice_move?
+      false
+    end
+
+    def identifying_fields
+      [@axis_corner, @direction]
+    end
+
+    def rotate_by(rotation)
+      nice_face =
+        find_only(@axis_corner.adjacent_faces) do |f|
+          f.same_axis?(rotation.axis_face)
+        end
+      nice_direction = rotation.translated_direction(nice_face)
+      nice_face_corners = nice_face.clockwise_corners
+      on_nice_face_index = nice_face_corners.index { |c| c.turned_equals?(@axis_corner) }
+      new_corner =
+        nice_face_corners[(on_nice_face_index + nice_direction.value) % nice_face_corners.length]
+      self.class.new(new_corner, @direction)
+    end
+
+    def mirror(normal_face)
+      faces = @axis_corner.adjacent_faces
+      replaced_face = find_only(faces) { |f| f.same_axis?(normal_face) }
+      new_corner =
+        Corner.between_faces(replace_once(faces, replaced_face, replaced_face.opposite))
+      self.class.new(new_corner, @direction.inverse)
+    end
+  end
 end