twisty_puzzles 0.0.1 → 0.0.6

data/lib/twisty_puzzles/abstract_move.rb

@@ -150,8 +150,7 @@ module TwistyPuzzles
       when :qtm then slice_factor * direction_factor
       when :htm then slice_factor
       when :stm then 1
-      when :qstm then direction_factor
-      when :sqtm then direction_factor
+      when :qstm, :sqtm then direction_factor
       else raise ArgumentError, "Invalid move metric #{metric.inspect}."
       end
     end

data/lib/twisty_puzzles/abstract_move_parser.rb

@@ -1,45 +1,44 @@
 # frozen_string_literal: true
 
 module TwistyPuzzles
-  
-    # Base class for move parsers.
-    class AbstractMoveParser
-      def regexp
-        raise NotImplementedError
-      end
+  # Base class for move parsers.
+  class AbstractMoveParser
+    def regexp
+      raise NotImplementedError
+    end
 
-      def parse_part_key(_name)
-        raise NotImplementedError
-      end
+    def parse_part_key(_name)
+      raise NotImplementedError
+    end
 
-      def parse_move_part(_name, _string)
-        raise NotImplementedError
-      end
+    def parse_move_part(_name, _string)
+      raise NotImplementedError
+    end
 
-      def move_type_creators
-        raise NotImplementedError
-      end
+    def move_type_creators
+      raise NotImplementedError
+    end
 
-      def parse_named_captures(match)
-        present_named_captures = match.named_captures.reject { |_n, v| v.nil? }
-        present_named_captures.map do |name, string|
-          key = parse_part_key(name).to_sym
-          value = parse_move_part(name, string)
-          [key, value]
-        end.to_h
-      end
+    def parse_named_captures(match)
+      present_named_captures = match.named_captures.compact
+      present_named_captures.map do |name, string|
+        key = parse_part_key(name).to_sym
+        value = parse_move_part(name, string)
+        [key, value]
+      end.to_h
+    end
 
-      def parse_move(move_string)
-        match = move_string.match(regexp)
-        if !match || !match.pre_match.empty? || !match.post_match.empty?
-          raise ArgumentError("Invalid move #{move_string}.")
-        end
+    def parse_move(move_string)
+      match = move_string.match(regexp)
+      if !match || !match.pre_match.empty? || !match.post_match.empty?
+        raise ArgumentError("Invalid move #{move_string}.")
+      end
 
-        parsed_parts = parse_named_captures(match)
-        move_type_creators.each do |parser|
-          return parser.create(parsed_parts) if parser.applies_to?(parsed_parts)
-        end
-        raise "No move type creator applies to #{parsed_parts}"
+      parsed_parts = parse_named_captures(match)
+      move_type_creators.each do |parser|
+        return parser.create(parsed_parts) if parser.applies_to?(parsed_parts)
       end
+      raise "No move type creator applies to #{parsed_parts}"
     end
+  end
 end

data/lib/twisty_puzzles/algorithm.rb

@@ -8,148 +8,147 @@ require 'twisty_puzzles/compiled_cube_algorithm'
 require 'twisty_puzzles/compiled_skewb_algorithm'
 
 module TwistyPuzzles
-  
-    # Represents a sequence of moves that can be applied to puzzle states.
-    class Algorithm
-      include ReversibleApplyable
-      include Comparable
-
-      def initialize(moves)
-        moves.each do |m|
-          raise TypeError, "#{m.inspect} is not a suitable move." unless m.is_a?(AbstractMove)
-        end
-        @moves = moves
-      end
-
-      EMPTY = Algorithm.new([])
+  # Represents a sequence of moves that can be applied to puzzle states.
+  class Algorithm
+    include ReversibleApplyable
+    include Comparable
 
-      # Creates a one move algorithm.
-      def self.move(move)
-        Algorithm.new([move])
+    def initialize(moves)
+      moves.each do |m|
+        raise TypeError, "#{m.inspect} is not a suitable move." unless m.is_a?(AbstractMove)
       end
+      @moves = moves
+    end
 
-      attr_reader :moves
+    EMPTY = Algorithm.new([])
 
-      def eql?(other)
-        self.class.equal?(other.class) && @moves == other.moves
-      end
+    # Creates a one move algorithm.
+    def self.move(move)
+      Algorithm.new([move])
+    end
 
-      alias == eql?
+    attr_reader :moves
 
-      def hash
-        @hash ||= ([self.class] + @moves).hash
-      end
+    def eql?(other)
+      self.class.equal?(other.class) && @moves == other.moves
+    end
 
-      def length
-        @moves.length
-      end
+    alias == eql?
 
-      def empty?
-        @moves.empty?
-      end
+    def hash
+      @hash ||= ([self.class] + @moves).hash
+    end
 
-      def to_s
-        @moves.join(' ')
-      end
+    def length
+      @moves.length
+    end
 
-      def inspect
-        "Algorithm(#{self})"
-      end
+    def empty?
+      @moves.empty?
+    end
 
-      def apply_to(cube_state)
-        case cube_state
-        when SkewbState
-          compiled_for_skewb.apply_to(cube_state)
-        when CubeState
-          compiled_for_cube(cube_state.n).apply_to(cube_state)
-        else
-          raise TypeError, "Unsupported cube state class #{cube_state.class}."
-        end
-      end
+    def to_s
+      @moves.join(' ')
+    end
 
-      def inverse
-        @inverse ||=
-          begin
-            alg = self.class.new(@moves.reverse.map(&:inverse))
-            alg.inverse = self
-            alg
-          end
-      end
+    def inspect
+      "Algorithm(#{self})"
+    end
 
-      def +(other)
-        self.class.new(@moves + other.moves)
+    def apply_to(cube_state)
+      case cube_state
+      when SkewbState
+        compiled_for_skewb.apply_to(cube_state)
+      when CubeState
+        compiled_for_cube(cube_state.n).apply_to(cube_state)
+      else
+        raise TypeError, "Unsupported cube state class #{cube_state.class}."
       end
+    end
 
-      def <=>(other)
-        [length, @moves] <=> [other.length, other.moves]
-      end
+    def inverse
+      @inverse ||=
+        begin
+          alg = self.class.new(@moves.reverse.map(&:inverse))
+          alg.inverse = self
+          alg
+        end
+    end
 
-      # Returns the cancelled version of the given algorithm.
-      # Note that the cube size is important to know which fat moves cancel
-      def cancelled(cube_size)
-        CancellationHelper.cancel(self, cube_size)
-      end
+    def +(other)
+      self.class.new(@moves + other.moves)
+    end
 
-      # Returns the number of moves that cancel if you concat the algorithm to the right of self.
-      # Note that the cube size is important to know which fat moves cancel
-      def cancellations(other, cube_size, metric = :htm)
-        CubeState.check_cube_size(cube_size)
-        AbstractMove.check_move_metric(metric)
-        cancelled = cancelled(cube_size)
-        other_cancelled = other.cancelled(cube_size)
-        together_cancelled = (self + other).cancelled(cube_size)
-        cancelled.move_count(cube_size, metric) +
-          other_cancelled.move_count(cube_size, metric) -
-          together_cancelled.move_count(cube_size, metric)
-      end
+    def <=>(other)
+      [length, @moves] <=> [other.length, other.moves]
+    end
 
-      # Rotates the algorithm, e.g. applying "y" to "R U" becomes "F U".
-      # Applying rotation r to alg a is equivalent to r' a r.
-      # Note that this is not implemented for all moves.
-      def rotate_by(rotation)
-        raise TypeError unless rotation.is_a?(Rotation)
-        return self if rotation.direction.zero?
+    # Returns the cancelled version of the given algorithm.
+    # Note that the cube size is important to know which fat moves cancel
+    def cancelled(cube_size)
+      CancellationHelper.cancel(self, cube_size)
+    end
 
-        self.class.new(@moves.map { |m| m.rotate_by(rotation) })
-      end
+    # Returns the number of moves that cancel if you concat the algorithm to the right of self.
+    # Note that the cube size is important to know which fat moves cancel
+    def cancellations(other, cube_size, metric = :htm)
+      CubeState.check_cube_size(cube_size)
+      AbstractMove.check_move_metric(metric)
+      cancelled = cancelled(cube_size)
+      other_cancelled = other.cancelled(cube_size)
+      together_cancelled = (self + other).cancelled(cube_size)
+      cancelled.move_count(cube_size, metric) +
+        other_cancelled.move_count(cube_size, metric) -
+        together_cancelled.move_count(cube_size, metric)
+    end
 
-      # Mirrors the algorithm and uses the given face as the normal of the mirroring.
-      # E.g. mirroring "R U F" with "R" as the normal face, we get "L U' F'".
-      def mirror(normal_face)
-        raise TypeError unless normal_face.is_a?(Face)
+    # Rotates the algorithm, e.g. applying "y" to "R U" becomes "F U".
+    # Applying rotation r to alg a is equivalent to r' a r.
+    # Note that this is not implemented for all moves.
+    def rotate_by(rotation)
+      raise TypeError unless rotation.is_a?(Rotation)
+      return self if rotation.direction.zero?
 
-        self.class.new(@moves.map { |m| m.mirror(normal_face) })
-      end
+      self.class.new(@moves.map { |m| m.rotate_by(rotation) })
+    end
 
-      # Cube size is needed to decide whether 'u' is a slice move (like on bigger cubes) or a
-      # fat move (like on 3x3).
-      def move_count(cube_size, metric = :htm)
-        raise TypeError unless cube_size.is_a?(Integer)
+    # Mirrors the algorithm and uses the given face as the normal of the mirroring.
+    # E.g. mirroring "R U F" with "R" as the normal face, we get "L U' F'".
+    def mirror(normal_face)
+      raise TypeError unless normal_face.is_a?(Face)
 
-        AbstractMove.check_move_metric(metric)
-        return 0 if empty?
+      self.class.new(@moves.map { |m| m.mirror(normal_face) })
+    end
 
-        @moves.map { |m| m.move_count(cube_size, metric) }.reduce(:+)
-      end
+    # Cube size is needed to decide whether 'u' is a slice move (like on bigger cubes) or a
+    # fat move (like on 3x3).
+    def move_count(cube_size, metric = :htm)
+      raise TypeError unless cube_size.is_a?(Integer)
 
-      def *(other)
-        raise TypeError unless other.is_a?(Integer)
-        raise ArgumentError if other.negative?
+      AbstractMove.check_move_metric(metric)
+      return 0 if empty?
 
-        self.class.new(@moves * other)
-      end
+      @moves.sum { |m| m.move_count(cube_size, metric) }
+    end
 
-      def compiled_for_skewb
-        @compiled_for_skewb ||= CompiledSkewbAlgorithm.for_moves(@moves)
-      end
+    def *(other)
+      raise TypeError unless other.is_a?(Integer)
+      raise ArgumentError if other.negative?
 
-      def compiled_for_cube(cube_size)
-        (@compiled_for_cube ||= {})[cube_size] ||=
-          CompiledCubeAlgorithm.for_moves(cube_size, @moves)
-      end
+      self.class.new(@moves * other)
+    end
 
-      protected
+    def compiled_for_skewb
+      @compiled_for_skewb ||= CompiledSkewbAlgorithm.for_moves(@moves)
+    end
 
-      attr_writer :inverse
+    def compiled_for_cube(cube_size)
+      (@compiled_for_cube ||= {})[cube_size] ||=
+        CompiledCubeAlgorithm.for_moves(cube_size, @moves)
     end
+
+    protected
+
+    attr_writer :inverse
+  end
 end

data/lib/twisty_puzzles/algorithm_transformation.rb

@@ -4,30 +4,28 @@ require 'twisty_puzzles/cube_direction'
 require 'twisty_puzzles/rotation'
 
 module TwistyPuzzles
-  
-    AlgorithmTransformation =
-      Struct.new(:rotation, :mirror, :mirror_normal_face) do
-        def transformed(algorithm)
-          algorithm = algorithm.mirror(mirror_normal_face) if mirror
-          algorithm.rotate_by(rotation)
-        end
+  AlgorithmTransformation =
+    Struct.new(:rotation, :mirror, :mirror_normal_face) do
+      def transformed(algorithm)
+        algorithm = algorithm.mirror(mirror_normal_face) if mirror
+        algorithm.rotate_by(rotation)
+      end
 
-        def identity?
-          rotation.identity? && !mirror
-        end
+      def identity?
+        rotation.identity? && !mirror
+      end
 
-        # Returns algorithm transformations that mirror an algorithm and rotate it around a face.
-        def self.around_face(face)
-          around_face_rotations = CubeDirection::ALL_DIRECTIONS.map { |d| Rotation.new(face, d) }
-          mirror_normal_face = face.neighbors.first
-          around_face_rotations.product([true, false]).map do |r, m|
-            AlgorithmTransformation.new(r, m, mirror_normal_face)
-          end
+      # Returns algorithm transformations that mirror an algorithm and rotate it around a face.
+      def self.around_face(face)
+        around_face_rotations = CubeDirection::ALL_DIRECTIONS.map { |d| Rotation.new(face, d) }
+        mirror_normal_face = face.neighbors.first
+        around_face_rotations.product([true, false]).map do |r, m|
+          AlgorithmTransformation.new(r, m, mirror_normal_face)
         end
+      end
 
-        def self.around_face_without_identity(face)
-          around_face(face).reject(&:identity?)
-        end
+      def self.around_face_without_identity(face)
+        around_face(face).reject(&:identity?)
       end
-  end
+    end
 end

data/lib/twisty_puzzles/axis_face_and_direction_move.rb

@@ -4,75 +4,75 @@ require 'twisty_puzzles/abstract_move'
 require 'twisty_puzzles/cube_direction'
 
 module TwistyPuzzles
-  
-    # Intermediate base class for all types of moves that have an axis face and a direction,
-    # i.e. cube moves and rotations.
-    class AxisFaceAndDirectionMove < AbstractMove
-      def initialize(axis_face, direction)
-        raise TypeError, "Unsuitable axis face #{axis_face}." unless axis_face.is_a?(Face)
-        raise TypeError unless direction.is_a?(CubeDirection)
+  # Intermediate base class for all types of moves that have an axis face and a direction,
+  # i.e. cube moves and rotations.
+  class AxisFaceAndDirectionMove < AbstractMove
+    def initialize(axis_face, direction)
+      raise TypeError, "Unsuitable axis face #{axis_face}." unless axis_face.is_a?(Face)
+      raise TypeError unless direction.is_a?(CubeDirection)
 
-        @axis_face = axis_face
-        @direction = direction
-      end
+      super()
+      @axis_face = axis_face
+      @direction = direction
+    end
 
-      attr_reader :direction, :axis_face
+    attr_reader :direction, :axis_face
 
-      def translated_direction(other_axis_face)
-        case @axis_face
-        when other_axis_face then @direction
-        when other_axis_face.opposite then @direction.inverse
-        else raise ArgumentError
-        end
+    def translated_direction(other_axis_face)
+      case @axis_face
+      when other_axis_face then @direction
+      when other_axis_face.opposite then @direction.inverse
+      else raise ArgumentError
       end
+    end
 
-      def same_axis?(other)
-        @axis_face.same_axis?(other.axis_face)
-      end
+    def same_axis?(other)
+      @axis_face.same_axis?(other.axis_face)
+    end
 
-      def identifying_fields
-        [@axis_face, @direction]
-      end
+    def identifying_fields
+      [@axis_face, @direction]
+    end
 
-      def canonical_direction
-        @axis_face.canonical_axis_face? ? @direction : @direction.inverse
-      end
+    def canonical_direction
+      @axis_face.canonical_axis_face? ? @direction : @direction.inverse
+    end
 
-      def can_swap?(other)
-        super || same_axis?(other)
-      end
+    def can_swap?(other)
+      super || same_axis?(other)
+    end
 
-      def swap_internal(other)
-        if same_axis?(other)
-          [other, self]
-        else
-          super
-        end
+    def swap_internal(other)
+      if same_axis?(other)
+        [other, self]
+      else
+        super
       end
+    end
 
-      def rotate_by(rotation)
-        if same_axis?(rotation)
-          self
-        else
-          rotation_neighbors = rotation.axis_face.neighbors
-          face_index = rotation_neighbors.index(@axis_face) || raise
-          new_axis_face =
-            rotation_neighbors[(face_index + rotation.direction.value) % rotation_neighbors.length]
-          fields = replace_once(identifying_fields, @axis_face, new_axis_face)
-          self.class.new(*fields)
-        end
+    def rotate_by(rotation)
+      if same_axis?(rotation)
+        self
+      else
+        rotation_neighbors = rotation.axis_face.neighbors
+        face_index = rotation_neighbors.index(@axis_face) || raise
+        new_axis_face =
+          rotation_neighbors[(face_index + rotation.direction.value) % rotation_neighbors.length]
+        fields = replace_once(identifying_fields, @axis_face, new_axis_face)
+        self.class.new(*fields)
       end
+    end
 
-      def mirror(normal_face)
-        if normal_face.same_axis?(@axis_face)
-          fields = replace_once(
-            replace_once(identifying_fields, @direction, @direction.inverse),
-            @axis_face, @axis_face.opposite
-          )
-          self.class.new(*fields)
-        else
-          inverse
-        end
+    def mirror(normal_face)
+      if normal_face.same_axis?(@axis_face)
+        fields = replace_once(
+          replace_once(identifying_fields, @direction, @direction.inverse),
+          @axis_face, @axis_face.opposite
+        )
+        self.class.new(*fields)
+      else
+        inverse
       end
     end
+  end
 end