twisty_puzzles 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c23d462856d3827fe5386ca3d4d3816c2ce37cf6e06eb3876a9e4b18c4aef36
-  data.tar.gz: 561a871d7287fde1d568a00b243dff15337c0ae785c3caa55e71a2e94a0d09a0
+  metadata.gz: 989d528a58cb32ca49f7502249b5e5eca71a1e46726f1a79ffa64e18381d5a86
+  data.tar.gz: 2c1bfff00d66c4b85f15592ee50fa6883e45149ae8456c7a24cc1cba60841285
 SHA512:
-  metadata.gz: b944ba73e3cf1c4cad55156237fd4c9a87888796ea5e6fbff6606c36a9d97b84a59e1c85a42318e70c71848399205dd117c8385a01d592be6f2bdbcdaeef3570
-  data.tar.gz: 41894ab27afc69dffef137acb506819be9d94b3b27b339ba3ff1bc75731736575f412609a7e127920d60c9c5954f808ef98deafee6ec27f23856f1e794f67fdd
+  metadata.gz: 870c957e8ba192090401e9e6092779e5f19f45fcd995d60ab1c2e52fed62b7cd25397ce06f18fb2eae6f4ac3df88e76975390f0b73ebc45a8fe2ecdc2cae41fd
+  data.tar.gz: 6140ebc4150d89e0577461b66b18158dec51c11d3527d265f028d24cd2b1e44f2299b05ae46a3264bbc040dcf0b34bda83be7ec15092884234539130a402d3ef

data/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.0.2]
+### Changed
+- Now a simple `require 'twisty_puzzles'` is enough, users don't need to require files separately.
+
+### Fixed
+- Syntax error in file that wasn't included in tests previously.
+- Rubocop fixes across the codebase.
+	
 ## [0.0.1]
 ### Added
-Split off core twisty puzzles functionality from cube_trainer repo into a Gem.
+- Split off core twisty puzzles functionality from cube_trainer repo into a Gem.

data/lib/twisty_puzzles.rb

@@ -1,5 +1,42 @@
 # frozen_string_literal: true
 
+require 'twisty_puzzles/abstract_direction'
+require 'twisty_puzzles/abstract_move'
+require 'twisty_puzzles/abstract_move_parser'
+require 'twisty_puzzles/algorithm'
+require 'twisty_puzzles/algorithm_transformation'
+require 'twisty_puzzles/axis_face_and_direction_move'
+require 'twisty_puzzles/cancellation_helper'
+require 'twisty_puzzles/color_scheme'
+require 'twisty_puzzles/commutator'
+require 'twisty_puzzles/compiled_algorithm'
+require 'twisty_puzzles/compiled_cube_algorithm'
+require 'twisty_puzzles/compiled_skewb_algorithm'
+require 'twisty_puzzles/coordinate'
+require 'twisty_puzzles/cube'
+require 'twisty_puzzles/cube_constants'
+require 'twisty_puzzles/cube_direction'
+require 'twisty_puzzles/cube_move'
+require 'twisty_puzzles/cube_move_parser'
+require 'twisty_puzzles/cube_print_helper'
+require 'twisty_puzzles/cube_state'
+require 'twisty_puzzles/letter_scheme'
+require 'twisty_puzzles/move_type_creator'
+require 'twisty_puzzles/parser'
+require 'twisty_puzzles/part_cycle_factory'
+require 'twisty_puzzles/puzzle'
+require 'twisty_puzzles/reversible_applyable'
+require 'twisty_puzzles/rotation'
+require 'twisty_puzzles/skewb_direction'
+require 'twisty_puzzles/skewb_move'
+require 'twisty_puzzles/skewb_move_parser'
+require 'twisty_puzzles/skewb_notation'
+require 'twisty_puzzles/skewb_state'
+require 'twisty_puzzles/state_helper'
+require 'twisty_puzzles/sticker_cycle'
+require 'twisty_puzzles/twisty_puzzles_error'
+require 'twisty_puzzles/version'
+
 # Libraries for the twisty puzzles.
 module TwistyPuzzles
 end

data/lib/twisty_puzzles/abstract_direction.rb

@@ -1,54 +1,53 @@
 # frozen_string_literal: true
 
 module TwistyPuzzles
-  
-    # Base class for directions.
-    class AbstractDirection
-      include Comparable
-      POSSIBLE_DIRECTION_NAMES = [[''], ['2', '2\''], ['\'', '3']].freeze
-      SIMPLE_DIRECTION_NAMES = (['0'] + POSSIBLE_DIRECTION_NAMES.map(&:first)).freeze
-      POSSIBLE_SKEWB_DIRECTION_NAMES = [['', '2\''], ['\'', '2']].freeze
-      SIMPLE_SKEWB_DIRECTION_NAMES = (['0'] + POSSIBLE_SKEWB_DIRECTION_NAMES.map(&:first)).freeze
-
-      def initialize(value)
-        raise TypeError, "Direction value #{value} isn't an integer." unless value.is_a?(Integer)
-        unless value >= 0 && value < self.class::NUM_DIRECTIONS
-          raise ArgumentError, "Invalid direction value #{value}."
-        end
-
-        @value = value
+  # Base class for directions.
+  class AbstractDirection
+    include Comparable
+    POSSIBLE_DIRECTION_NAMES = [[''], ['2', '2\''], ['\'', '3']].freeze
+    SIMPLE_DIRECTION_NAMES = (['0'] + POSSIBLE_DIRECTION_NAMES.map(&:first)).freeze
+    POSSIBLE_SKEWB_DIRECTION_NAMES = [['', '2\''], ['\'', '2']].freeze
+    SIMPLE_SKEWB_DIRECTION_NAMES = (['0'] + POSSIBLE_SKEWB_DIRECTION_NAMES.map(&:first)).freeze
+
+    def initialize(value)
+      raise TypeError, "Direction value #{value} isn't an integer." unless value.is_a?(Integer)
+      unless value >= 0 && value < self.class::NUM_DIRECTIONS
+        raise ArgumentError, "Invalid direction value #{value}."
       end
 
-      attr_reader :value
+      @value = value
+    end
 
-      def <=>(other)
-        @value <=> other.value
-      end
+    attr_reader :value
 
-      def zero?
-        @value.zero?
-      end
+    def <=>(other)
+      @value <=> other.value
+    end
 
-      def non_zero?
-        @value.positive?
-      end
+    def zero?
+      @value.zero?
+    end
 
-      def inverse
-        self.class.new((self.class::NUM_DIRECTIONS - @value) % self.class::NUM_DIRECTIONS)
-      end
+    def non_zero?
+      @value.positive?
+    end
 
-      def +(other)
-        self.class.new((@value + other.value) % self.class::NUM_DIRECTIONS)
-      end
+    def inverse
+      self.class.new((self.class::NUM_DIRECTIONS - @value) % self.class::NUM_DIRECTIONS)
+    end
 
-      def eql?(other)
-        self.class.equal?(other.class) && @value == other.value
-      end
+    def +(other)
+      self.class.new((@value + other.value) % self.class::NUM_DIRECTIONS)
+    end
+
+    def eql?(other)
+      self.class.equal?(other.class) && @value == other.value
+    end
 
-      alias == eql?
+    alias == eql?
 
-      def hash
-        @value.hash
-      end
+    def hash
+      @value.hash
     end
+  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.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_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.map { |m| m.move_count(cube_size, metric) }.reduce(:+)
+    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