twisty_puzzles 0.0.1 → 0.0.2

data/lib/twisty_puzzles/cube_state.rb

@@ -9,105 +9,104 @@ require 'twisty_puzzles/utils/array_helper'
 require 'twisty_puzzles/native'
 
 module TwistyPuzzles
-  
-    # Represents the state (i.e. the sticker positions) of a cube.
-    class CubeState
-      include Utils::ArrayHelper
-      include CubePrintHelper
-      include StateHelper
-      include CubeConstants
-
-      def self.check_cube_size(cube_size)
-        raise TypeError unless cube_size.is_a?(Integer)
-        raise ArgumentError, 'Cubes of size smaller than 2 are not supported.' if cube_size < 2
-      end
-
-      def self.from_stickers(cube_size, stickers)
-        CubeState.check_cube_size(cube_size)
-        unless stickers.length == FACE_SYMBOLS.length
-          raise ArgumentError, "Cubes must have #{FACE_SYMBOLS.length} sides."
-        end
-
-        unless stickers.all? { |p| p.length == cube_size && p.all? { |q| q.length == cube_size } }
-          raise ArgumentError,
-                "All sides of a #{cube_size}x#{cube_size} must be #{cube_size}x#{cube_size}."
-        end
+  # Represents the state (i.e. the sticker positions) of a cube.
+  class CubeState
+    include Utils::ArrayHelper
+    include CubePrintHelper
+    include StateHelper
+    include CubeConstants
+
+    def self.check_cube_size(cube_size)
+      raise TypeError unless cube_size.is_a?(Integer)
+      raise ArgumentError, 'Cubes of size smaller than 2 are not supported.' if cube_size < 2
+    end
 
-        stickers_hash = create_stickers_hash(stickers)
-        new(Native::CubeState.new(cube_size, stickers_hash))
+    def self.from_stickers(cube_size, stickers)
+      CubeState.check_cube_size(cube_size)
+      unless stickers.length == FACE_SYMBOLS.length
+        raise ArgumentError, "Cubes must have #{FACE_SYMBOLS.length} sides."
       end
 
-      def self.create_stickers_hash(stickers)
-        FACE_SYMBOLS.zip(stickers).map do |face_symbol, face_stickers|
-          face = Face.for_face_symbol(face_symbol)
-          face_hash = {
-            stickers: face_stickers,
-            # Note that in the ruby code, x and y are exchanged s.t. one can say bla[x][y],
-            # but the C code does the more logical thing,
-            # so we have to swap coordinates here.
-            x_base_face_symbol: face.coordinate_index_base_face(1).face_symbol,
-            y_base_face_symbol: face.coordinate_index_base_face(0).face_symbol
-          }
-          [face_symbol, face_hash]
-        end.to_h
+      unless stickers.all? { |p| p.length == cube_size && p.all? { |q| q.length == cube_size } }
+        raise ArgumentError,
+              "All sides of a #{cube_size}x#{cube_size} must be #{cube_size}x#{cube_size}."
       end
 
-      def initialize(native)
-        raise TypeError unless native.is_a?(Native::CubeState)
+      stickers_hash = create_stickers_hash(stickers)
+      new(Native::CubeState.new(cube_size, stickers_hash))
+    end
 
-        @native = native
-      end
+    def self.create_stickers_hash(stickers)
+      FACE_SYMBOLS.zip(stickers).map do |face_symbol, face_stickers|
+        face = Face.for_face_symbol(face_symbol)
+        face_hash = {
+          stickers: face_stickers,
+          # Note that in the ruby code, x and y are exchanged s.t. one can say bla[x][y],
+          # but the C code does the more logical thing,
+          # so we have to swap coordinates here.
+          x_base_face_symbol: face.coordinate_index_base_face(1).face_symbol,
+          y_base_face_symbol: face.coordinate_index_base_face(0).face_symbol
+        }
+        [face_symbol, face_hash]
+      end.to_h
+    end
 
-      def dup
-        CubeState.new(@native.dup)
-      end
+    def initialize(native)
+      raise TypeError unless native.is_a?(Native::CubeState)
 
-      attr_reader :native
+      @native = native
+    end
 
-      def n
-        @native.cube_size
-      end
+    def dup
+      CubeState.new(@native.dup)
+    end
 
-      def stickers; end
+    attr_reader :native
 
-      def eql?(other)
-        self.class.equal?(other.class) && @native == other.native
-      end
+    def n
+      @native.cube_size
+    end
 
-      alias == eql?
+    def stickers; end
 
-      def hash
-        @hash ||= [self.class, @native].hash
-      end
+    def eql?(other)
+      self.class.equal?(other.class) && @native == other.native
+    end
 
-      # TODO: Get rid of this backwards compatibility artifact
-      def sticker_array(face)
-        raise TypeError unless face.is_a?(Face)
+    alias == eql?
 
-        @native.sticker_array(
-          face.face_symbol,
-          # Note that in the ruby code, x and y are exchanged s.t. one can say bla[x][y],
-          # but the C code does the more logical thing,
-          # so we have to swap coordinates here.
-          face.coordinate_index_base_face(1).face_symbol,
-          face.coordinate_index_base_face(0).face_symbol
-        )
-      end
+    def hash
+      @hash ||= [self.class, @native].hash
+    end
 
-      def to_s
-        cube_string(self, :nocolor)
-      end
+    # TODO: Get rid of this backwards compatibility artifact
+    def sticker_array(face)
+      raise TypeError unless face.is_a?(Face)
+
+      @native.sticker_array(
+        face.face_symbol,
+        # Note that in the ruby code, x and y are exchanged s.t. one can say bla[x][y],
+        # but the C code does the more logical thing,
+        # so we have to swap coordinates here.
+        face.coordinate_index_base_face(1).face_symbol,
+        face.coordinate_index_base_face(0).face_symbol
+      )
+    end
 
-      def colored_to_s
-        cube_string(self, :color)
-      end
+    def to_s
+      cube_string(self, :nocolor)
+    end
 
-      def [](coordinate)
-        @native[coordinate.native]
-      end
+    def colored_to_s
+      cube_string(self, :color)
+    end
 
-      def []=(coordinate, color)
-        @native[coordinate.native] = color
-      end
+    def [](coordinate)
+      @native[coordinate.native]
+    end
+
+    def []=(coordinate, color)
+      @native[coordinate.native] = color
     end
+  end
 end

data/lib/twisty_puzzles/move_type_creator.rb

@@ -1,27 +1,26 @@
 # frozen_string_literal: true
 
 module TwistyPuzzles
-  
-    # Class for creating one move type from its parts.
-    # Helper class for parsing logic.
-    class MoveTypeCreator
-      def initialize(capture_keys, move_class)
-        raise TypeError unless move_class.is_a?(Class)
-        raise TypeError unless capture_keys.all? { |k| k.is_a?(Symbol) }
+  # Class for creating one move type from its parts.
+  # Helper class for parsing logic.
+  class MoveTypeCreator
+    def initialize(capture_keys, move_class)
+      raise TypeError unless move_class.is_a?(Class)
+      raise TypeError unless capture_keys.all? { |k| k.is_a?(Symbol) }
 
-        @capture_keys = capture_keys.freeze
-        @move_class = move_class
-      end
+      @capture_keys = capture_keys.freeze
+      @move_class = move_class
+    end
 
-      def applies_to?(parsed_parts)
-        parsed_parts.keys.sort == @capture_keys.sort
-      end
+    def applies_to?(parsed_parts)
+      parsed_parts.keys.sort == @capture_keys.sort
+    end
 
-      def create(parsed_parts)
-        raise ArgumentError unless applies_to?(parsed_parts)
+    def create(parsed_parts)
+      raise ArgumentError unless applies_to?(parsed_parts)
 
-        fields = @capture_keys.map { |name| parsed_parts[name] }
-        @move_class.new(*fields)
-      end
+      fields = @capture_keys.map { |name| parsed_parts[name] }
+      @move_class.new(*fields)
     end
+  end
 end

data/lib/twisty_puzzles/parser.rb

@@ -6,217 +6,214 @@ require 'twisty_puzzles/cube_move_parser'
 require 'twisty_puzzles/skewb_move_parser'
 require 'twisty_puzzles/twisty_puzzles_error'
 
-module TwistyPuzzles
-  # rubocop:disable Style/Documentation
-  
-    # rubocop:enable Style/Documentation
-    class CommutatorParseError < TwistyPuzzlesError
-    end
-
-    # Parser for commutators and algorithms.
-    class Parser
-      OPENING_BRACKET = '['
-      OPENING_PAREN = '('
-      CLOSING_BRACKET = ']'
-      CLOSING_PAREN = ')'
-      TIMES = '*'
-
-      def initialize(alg_string, move_parser)
-        @alg_string = alg_string
-        @scanner = StringScanner.new(alg_string)
-        @move_parser = move_parser
-      end
-
-      def parse_open_paren
-        complain('beginning of trigger') unless @scanner.getch == OPENING_PAREN
-      end
-
-      def parse_close_paren
-        complain('end of trigger') unless @scanner.getch == CLOSING_PAREN
-      end
+module TwistyPuzzles # rubocop:disable Style/Documentation
+  class CommutatorParseError < TwistyPuzzlesError
+  end
+
+  # Parser for commutators and algorithms.
+  class Parser
+    OPENING_BRACKET = '['
+    OPENING_PAREN = '('
+    CLOSING_BRACKET = ']'
+    CLOSING_PAREN = ')'
+    TIMES = '*'
+
+    def initialize(alg_string, move_parser)
+      @alg_string = alg_string
+      @scanner = StringScanner.new(alg_string)
+      @move_parser = move_parser
+    end
 
-      def parse_times
-        complain('times symbol of multiplier') unless @scanner.getch == TIMES
-      end
+    def parse_open_paren
+      complain('beginning of trigger') unless @scanner.getch == OPENING_PAREN
+    end
 
-      def parse_factor
-        number = @scanner.scan(/\d+/)
-        complain('factor of multiplier') unless number
-        Integer(number, 10)
-      end
+    def parse_close_paren
+      complain('end of trigger') unless @scanner.getch == CLOSING_PAREN
+    end
 
-      def parse_multiplier
-        skip_spaces
-        parse_times
-        skip_spaces
-        parse_factor
-      end
+    def parse_times
+      complain('times symbol of multiplier') unless @scanner.getch == TIMES
+    end
 
-      def parse_trigger
-        parse_open_paren
-        skip_spaces
-        moves = parse_moves_with_triggers
-        skip_spaces
-        parse_close_paren
-        skip_spaces
-        case @scanner.peek(1)
-        when TIMES
-          moves * parse_multiplier
-        when ('0'..'9')
-          moves * parse_factor
-        else
-          moves
-        end
-      end
+    def parse_factor
+      number = @scanner.scan(/\d+/)
+      complain('factor of multiplier') unless number
+      Integer(number, 10)
+    end
 
-      # Parses at least one move and allows for triggers in parentheses.
-      def parse_moves_with_triggers
-        skip_spaces
-        if @scanner.peek(1) == OPENING_PAREN
-          parse_trigger + parse_moves_with_triggers
-        else
-          parse_moves
-        end
-      end
+    def parse_multiplier
+      skip_spaces
+      parse_times
+      skip_spaces
+      parse_factor
+    end
 
-      # Parses at least one move.
-      def parse_nonempty_moves
-        moves = parse_moves
-        complain('move') if moves.empty?
+    def parse_trigger
+      parse_open_paren
+      skip_spaces
+      moves = parse_moves_with_triggers
+      skip_spaces
+      parse_close_paren
+      skip_spaces
+      case @scanner.peek(1)
+      when TIMES
+        moves * parse_multiplier
+      when ('0'..'9')
+        moves * parse_factor
+      else
         moves
       end
+    end
 
-      # Parses a series of moves.
-      def parse_moves
-        moves = []
-        while (m = begin skip_spaces; parse_move_internal end)
-          moves.push(m)
-        end
-        Algorithm.new(moves)
-      end
-
-      def complain(parsed_object)
-        raise CommutatorParseError, <<~ERROR.chomp
-          Couldn't parse #{parsed_object} here:
-            #{@alg_string}
-            #{' ' * @scanner.pos}^"
-        ERROR
-      end
-
-      def check_eos(parsed_object)
-        complain("end of #{parsed_object}") unless @scanner.eos?
-      end
-
-      def parse_open_bracket
-        complain('beginning of commutator') unless @scanner.getch == OPENING_BRACKET
+    # Parses at least one move and allows for triggers in parentheses.
+    def parse_moves_with_triggers
+      skip_spaces
+      if @scanner.peek(1) == OPENING_PAREN
+        parse_trigger + parse_moves_with_triggers
+      else
+        parse_moves
       end
+    end
 
-      def parse_close_bracket
-        complain('end of commutator') unless @scanner.getch == CLOSING_BRACKET
-      end
+    # Parses at least one move.
+    def parse_nonempty_moves
+      moves = parse_moves
+      complain('move') if moves.empty?
+      moves
+    end
 
-      def parse_commutator
-        skip_spaces
-        if @scanner.peek(1) == OPENING_BRACKET
-          parse_commutator_internal
-        else
-          FakeCommutator.new(parse_moves_with_triggers)
-        end
+    # Parses a series of moves.
+    def parse_moves
+      moves = []
+      while (m = begin skip_spaces; parse_move_internal end)
+        moves.push(m)
       end
+      Algorithm.new(moves)
+    end
 
-      def parse_algorithm
-        skip_spaces
-        parse_moves_with_triggers
-      end
+    def complain(parsed_object)
+      raise CommutatorParseError, <<~ERROR.chomp
+        Couldn't parse #{parsed_object} here:
+          #{@alg_string}
+          #{' ' * @scanner.pos}^"
+      ERROR
+    end
 
-      def parse_setup_commutator_inner
-        skip_spaces
-        if @scanner.peek(1) == OPENING_BRACKET
-          parse_pure_commutator
-        else
-          FakeCommutator.new(parse_moves_with_triggers)
-        end
-      end
+    def check_eos(parsed_object)
+      complain("end of #{parsed_object}") unless @scanner.eos?
+    end
 
-      def parse_pure_commutator
-        skip_spaces
-        parse_open_bracket
-        first_part = parse_nonempty_moves
-        skip_spaces
-        complain('middle of pure commutator') unless @scanner.getch == ','
-        second_part = parse_nonempty_moves
-        skip_spaces
-        parse_close_bracket
-        PureCommutator.new(first_part, second_part)
-      end
+    def parse_open_bracket
+      complain('beginning of commutator') unless @scanner.getch == OPENING_BRACKET
+    end
 
-      def parse_commutator_internal_after_separator(setup_or_first_part, separator)
-        if [':', ';'].include?(separator)
-          inner_commutator = parse_setup_commutator_inner
-          SetupCommutator.new(setup_or_first_part, inner_commutator)
-        elsif separator == ','
-          second_part = parse_nonempty_moves
-          PureCommutator.new(setup_or_first_part, second_part)
-        else
-          complain('end of setup or middle of pure commutator') unless @scanner.eos?
-        end
-      end
+    def parse_close_bracket
+      complain('end of commutator') unless @scanner.getch == CLOSING_BRACKET
+    end
 
-      def parse_commutator_internal
-        skip_spaces
-        parse_open_bracket
-        setup_or_first_part = parse_nonempty_moves
-        skip_spaces
-        separator = @scanner.getch
-        comm = parse_commutator_internal_after_separator(setup_or_first_part, separator)
-        skip_spaces
-        parse_close_bracket
-        skip_spaces
-        complain('end of commutator') unless @scanner.eos?
-        comm
+    def parse_commutator
+      skip_spaces
+      if @scanner.peek(1) == OPENING_BRACKET
+        parse_commutator_internal
+      else
+        FakeCommutator.new(parse_moves_with_triggers)
       end
+    end
 
-      def parse_move_internal
-        move = @scanner.scan(@move_parser.regexp)
-        return unless move
-
-        @move_parser.parse_move(move)
-      end
+    def parse_algorithm
+      skip_spaces
+      parse_moves_with_triggers
+    end
 
-      def skip_spaces
-        @scanner.skip(/\s+/)
+    def parse_setup_commutator_inner
+      skip_spaces
+      if @scanner.peek(1) == OPENING_BRACKET
+        parse_pure_commutator
+      else
+        FakeCommutator.new(parse_moves_with_triggers)
       end
     end
 
-    def parse_commutator(alg_string, complete_parse = true)
-      parser = Parser.new(alg_string, CubeMoveParser::INSTANCE)
-      commutator = parser.parse_commutator
-      parser.check_eos('commutator') if complete_parse
-      commutator
+    def parse_pure_commutator
+      skip_spaces
+      parse_open_bracket
+      first_part = parse_nonempty_moves
+      skip_spaces
+      complain('middle of pure commutator') unless @scanner.getch == ','
+      second_part = parse_nonempty_moves
+      skip_spaces
+      parse_close_bracket
+      PureCommutator.new(first_part, second_part)
     end
 
-    def parse_cube_algorithm(alg_string, complete_parse = true)
-      parser = Parser.new(alg_string, CubeMoveParser::INSTANCE)
-      algorithm = parser.parse_algorithm
-      parser.check_eos('algorithm') if complete_parse
-      algorithm
+    def parse_commutator_internal_after_separator(setup_or_first_part, separator)
+      if [':', ';'].include?(separator)
+        inner_commutator = parse_setup_commutator_inner
+        SetupCommutator.new(setup_or_first_part, inner_commutator)
+      elsif separator == ','
+        second_part = parse_nonempty_moves
+        PureCommutator.new(setup_or_first_part, second_part)
+      else
+        complain('end of setup or middle of pure commutator') unless @scanner.eos?
+      end
     end
 
-    def parse_cube_move(move_string)
-      CubeMoveParser::INSTANCE.parse_move(move_string)
+    def parse_commutator_internal
+      skip_spaces
+      parse_open_bracket
+      setup_or_first_part = parse_nonempty_moves
+      skip_spaces
+      separator = @scanner.getch
+      comm = parse_commutator_internal_after_separator(setup_or_first_part, separator)
+      skip_spaces
+      parse_close_bracket
+      skip_spaces
+      complain('end of commutator') unless @scanner.eos?
+      comm
     end
 
-    alias parse_algorithm parse_cube_algorithm
-    alias parse_move parse_cube_move
+    def parse_move_internal
+      move = @scanner.scan(@move_parser.regexp)
+      return unless move
 
-    def parse_skewb_algorithm(alg_string, notation, complete_parse = true)
-      parser = Parser.new(alg_string, SkewbMoveParser.new(notation))
-      algorithm = parser.parse_algorithm
-      parser.check_eos('algorithm') if complete_parse
-      algorithm
+      @move_parser.parse_move(move)
     end
 
-    def parse_skewb_move(move_string, notation)
-      SkewbMoveParser.new(notation).parse_move(move_string)
+    def skip_spaces
+      @scanner.skip(/\s+/)
     end
+  end
+
+  def parse_commutator(alg_string, complete_parse = true)
+    parser = Parser.new(alg_string, CubeMoveParser::INSTANCE)
+    commutator = parser.parse_commutator
+    parser.check_eos('commutator') if complete_parse
+    commutator
+  end
+
+  def parse_cube_algorithm(alg_string, complete_parse = true)
+    parser = Parser.new(alg_string, CubeMoveParser::INSTANCE)
+    algorithm = parser.parse_algorithm
+    parser.check_eos('algorithm') if complete_parse
+    algorithm
+  end
+
+  def parse_cube_move(move_string)
+    CubeMoveParser::INSTANCE.parse_move(move_string)
+  end
+
+  alias parse_algorithm parse_cube_algorithm
+  alias parse_move parse_cube_move
+
+  def parse_skewb_algorithm(alg_string, notation, complete_parse = true)
+    parser = Parser.new(alg_string, SkewbMoveParser.new(notation))
+    algorithm = parser.parse_algorithm
+    parser.check_eos('algorithm') if complete_parse
+    algorithm
+  end
+
+  def parse_skewb_move(move_string, notation)
+    SkewbMoveParser.new(notation).parse_move(move_string)
+  end
 end