twisty_puzzles 0.0.1 → 0.0.6

data/lib/twisty_puzzles/cube_move_parser.rb

@@ -10,91 +10,90 @@ require 'twisty_puzzles/rotation'
 require 'twisty_puzzles/skewb_move'
 
 module TwistyPuzzles
-  
-    # Parser for cube moves.
-    class CubeMoveParser < AbstractMoveParser
-      REGEXP =
-        begin
-                        axes_part = "(?<axis_name>[#{AbstractMove::AXES.join}])"
-                        face_names = CubeConstants::FACE_NAMES.join
-                        fat_move_part =
-                          "(?<width>\\d*)(?<fat_face_name>[#{face_names}])w"
-                        normal_move_part = "(?<face_name>[#{face_names}])"
-                        downcased_face_names = face_names.downcase
-                        maybe_fat_maybe_slice_move_part =
-                          "(?<maybe_fat_face_maybe_slice_name>[#{downcased_face_names}])"
-                        slice_move_part =
-                          "(?<slice_index>\\d+)(?<slice_name>[#{downcased_face_names}])"
-                        mslice_move_part =
-                          "(?<mslice_name>[#{AbstractMove::SLICE_FACES.keys.join}])"
-                        move_part = "(?:#{axes_part}|" \
-                                    "#{fat_move_part}|" \
-                                    "#{normal_move_part}|" \
-                                    "#{maybe_fat_maybe_slice_move_part}|" \
-                                    "#{slice_move_part}|#{mslice_move_part})"
-                        direction_names =
-                          AbstractDirection::POSSIBLE_DIRECTION_NAMES.flatten
-                        direction_names.sort_by! { |e| -e.length }
-                        direction_part = "(?<direction>#{direction_names.join('|')})"
-                        Regexp.new("#{move_part}#{direction_part}")
-                      end
+  # Parser for cube moves.
+  class CubeMoveParser < AbstractMoveParser
+    REGEXP =
+      begin
+        axes_part = "(?<axis_name>[#{AbstractMove::AXES.join}])"
+        face_names = CubeConstants::FACE_NAMES.join
+        fat_move_part =
+          "(?<width>\\d*)(?<fat_face_name>[#{face_names}])w"
+        normal_move_part = "(?<face_name>[#{face_names}])"
+        downcased_face_names = face_names.downcase
+        maybe_fat_maybe_slice_move_part =
+          "(?<maybe_fat_face_maybe_slice_name>[#{downcased_face_names}])"
+        slice_move_part =
+          "(?<slice_index>\\d+)(?<slice_name>[#{downcased_face_names}])"
+        mslice_move_part =
+          "(?<mslice_name>[#{AbstractMove::SLICE_FACES.keys.join}])"
+        move_part = "(?:#{axes_part}|" \
+                    "#{fat_move_part}|" \
+                    "#{normal_move_part}|" \
+                    "#{maybe_fat_maybe_slice_move_part}|" \
+                    "#{slice_move_part}|#{mslice_move_part})"
+        direction_names =
+          AbstractDirection::POSSIBLE_DIRECTION_NAMES.flatten
+        direction_names.sort_by! { |e| -e.length }
+        direction_part = "(?<direction>#{direction_names.join('|')})"
+        Regexp.new("#{move_part}#{direction_part}")
+      end
 
-      MOVE_TYPE_CREATORS = [
-        MoveTypeCreator.new(%i[axis_face direction], Rotation),
-        MoveTypeCreator.new(%i[fat_face direction width], FatMove),
-        MoveTypeCreator.new(%i[face direction], FatMove),
-        MoveTypeCreator.new(%i[maybe_fat_face_maybe_slice_face direction], MaybeFatMaybeSliceMove),
-        MoveTypeCreator.new(%i[slice_face direction slice_index], SliceMove),
-        MoveTypeCreator.new(%i[mslice_face direction], MaybeFatMSliceMaybeInnerMSliceMove)
-      ].freeze
+    MOVE_TYPE_CREATORS = [
+      MoveTypeCreator.new(%i[axis_face direction], Rotation),
+      MoveTypeCreator.new(%i[fat_face direction width], FatMove),
+      MoveTypeCreator.new(%i[face direction], FatMove),
+      MoveTypeCreator.new(%i[maybe_fat_face_maybe_slice_face direction], MaybeFatMaybeSliceMove),
+      MoveTypeCreator.new(%i[slice_face direction slice_index], SliceMove),
+      MoveTypeCreator.new(%i[mslice_face direction], MaybeFatMSliceMaybeInnerMSliceMove)
+    ].freeze
 
-      INSTANCE = CubeMoveParser.new
-      def regexp
-        REGEXP
-      end
+    INSTANCE = CubeMoveParser.new
+    def regexp
+      REGEXP
+    end
 
-      def move_type_creators
-        MOVE_TYPE_CREATORS
-      end
+    def move_type_creators
+      MOVE_TYPE_CREATORS
+    end
 
-      def parse_part_key(name)
-        name.sub('_name', '_face').sub('face_face', 'face')
-      end
+    def parse_part_key(name)
+      name.sub('_name', '_face').sub('face_face', 'face')
+    end
 
-      def parse_direction(direction_string)
-        value = AbstractDirection::POSSIBLE_DIRECTION_NAMES.index do |ds|
-          ds.include?(direction_string)
-        end + 1
-        CubeDirection.new(value)
-      end
+    def parse_direction(direction_string)
+      value = AbstractDirection::POSSIBLE_DIRECTION_NAMES.index do |ds|
+        ds.include?(direction_string)
+      end + 1
+      CubeDirection.new(value)
+    end
 
-      def parse_axis_face(axis_face_string)
-        Face::ELEMENTS[AbstractMove::AXES.index(axis_face_string)]
-      end
+    def parse_axis_face(axis_face_string)
+      Face::ELEMENTS[AbstractMove::AXES.index(axis_face_string)]
+    end
 
-      def parse_mslice_face(mslice_name)
-        AbstractMove::SLICE_FACES[mslice_name]
-      end
+    def parse_mslice_face(mslice_name)
+      AbstractMove::SLICE_FACES[mslice_name]
+    end
 
-      def parse_width(width_string)
-        width_string.empty? ? 2 : Integer(width_string, 10)
-      end
+    def parse_width(width_string)
+      width_string.empty? ? 2 : Integer(width_string, 10)
+    end
 
-      # rubocop:disable Metrics/CyclomaticComplexity
-      def parse_move_part(name, value)
-        case name
-        when 'axis_name' then parse_axis_face(value)
-        when 'width' then parse_width(value)
-        when 'slice_index' then Integer(value, 10)
-        when 'fat_face_name', 'face_name' then Face.by_name(value)
-        when 'maybe_fat_face_maybe_slice_name', 'slice_name'
-          Face.by_name(value.upcase)
-        when 'mslice_name'
-          parse_mslice_face(value)
-        when 'direction' then parse_direction(value)
-        else raise
-        end
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def parse_move_part(name, value)
+      case name
+      when 'axis_name' then parse_axis_face(value)
+      when 'width' then parse_width(value)
+      when 'slice_index' then Integer(value, 10)
+      when 'fat_face_name', 'face_name' then Face.by_name(value)
+      when 'maybe_fat_face_maybe_slice_name', 'slice_name'
+        Face.by_name(value.upcase)
+      when 'mslice_name'
+        parse_mslice_face(value)
+      when 'direction' then parse_direction(value)
+      else raise
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
     end
+    # rubocop:enable Metrics/CyclomaticComplexity
+  end
 end

data/lib/twisty_puzzles/cube_print_helper.rb

@@ -4,157 +4,157 @@ require 'colorize'
 require 'twisty_puzzles/utils/array_helper'
 
 module TwistyPuzzles
-  
-    # Module to print and display cube and Skewb states.
-    module CubePrintHelper
-      include Utils::ArrayHelper
-
-      def color_symbol(color)
-        case color
-        when :orange then :light_red
-        when :unknown then :light_black
-        else color
-        end
+  # Module to print and display cube and Skewb states.
+  module CubePrintHelper
+    include Utils::ArrayHelper
+
+    def color_symbol(color)
+      case color
+      when :orange then :light_red
+      when :unknown then :light_black
+      else color
       end
+    end
 
-      COLOR_MODES = %i[color nocolor].freeze
-      ColorInfo = Struct.new(:reverse_lines_mode, :reverse_columns_mode, :skewb_corner_permutation)
-      FACE_SYMBOL_INFOS = {
-        U: ColorInfo.new(:reverse, :reverse, [2, 3, 0, 1]),
-        L: ColorInfo.new(:keep, :reverse, [2, 0, 3, 1]),
-        F: ColorInfo.new(:keep, :reverse, [2, 0, 3, 1]),
-        R: ColorInfo.new(:keep, :keep, [1, 0, 3, 2]),
-        B: ColorInfo.new(:keep, :keep, [1, 0, 3, 2]),
-        D: ColorInfo.new(:keep, :reverse, [2, 0, 3, 1])
-      }.freeze
-
-      def color_character(color, color_mode)
-        unless COLOR_MODES.include?(color_mode)
-          raise ArgumentError, "Invalid color mode #{color_mode}"
-        end
-
-        char = color.to_s[0].upcase
-        if color_mode == :color
-          char.colorize(background: color_symbol(color))
-        else
-          char
-        end
+    COLOR_MODES = %i[color nocolor].freeze
+    ColorInfo = Struct.new(:reverse_lines_mode, :reverse_columns_mode, :skewb_corner_permutation)
+    FACE_SYMBOL_INFOS = {
+      U: ColorInfo.new(:reverse, :reverse, [2, 3, 0, 1]),
+      L: ColorInfo.new(:keep, :reverse, [2, 0, 3, 1]),
+      F: ColorInfo.new(:keep, :reverse, [2, 0, 3, 1]),
+      R: ColorInfo.new(:keep, :keep, [1, 0, 3, 2]),
+      B: ColorInfo.new(:keep, :keep, [1, 0, 3, 2]),
+      D: ColorInfo.new(:keep, :reverse, [2, 0, 3, 1])
+    }.freeze
+
+    def color_character(color, color_mode)
+      unless COLOR_MODES.include?(color_mode)
+        raise ArgumentError, "Invalid color mode #{color_mode}"
       end
 
-      def maybe_reverse(reverse_mode, stuff)
-        if reverse_mode == :reverse
-          stuff.reverse
-        elsif reverse_mode == :keep
-          stuff
-        else
-          raise
-        end
+      char = color.to_s[0].upcase
+      if color_mode == :color
+        char.colorize(background: color_symbol(color))
+      else
+        char
       end
+    end
 
-      def face_lines(cube_state, face_symbol, row_multiplicity = 1, column_multiplicity = 1)
-        face = Face.for_face_symbol(face_symbol)
-        face_symbol_info = FACE_SYMBOL_INFOS[face_symbol]
-        stickers = cube_state.sticker_array(face)
-        lines =
-          stickers.collect_concat do |sticker_line|
-            line = sticker_line.map { |c| yield(c) * column_multiplicity }
-            [maybe_reverse(face_symbol_info.reverse_columns_mode, line).join] * row_multiplicity
-          end
-        maybe_reverse(face_symbol_info.reverse_lines_mode, lines)
+    def maybe_reverse(reverse_mode, stuff)
+      case reverse_mode
+      when :reverse
+        stuff.reverse
+      when :keep
+        stuff
+      else
+        raise
       end
+    end
 
-      def simple_face_lines(cube_state, face_symbol, color_mode)
-        face_lines(cube_state, face_symbol) { |c| color_character(c, color_mode) }
-      end
+    def face_lines(cube_state, face_symbol, row_multiplicity = 1, column_multiplicity = 1)
+      face = Face.for_face_symbol(face_symbol)
+      face_symbol_info = FACE_SYMBOL_INFOS[face_symbol]
+      stickers = cube_state.sticker_array(face)
+      lines =
+        stickers.collect_concat do |sticker_line|
+          line = sticker_line.map { |c| yield(c) * column_multiplicity }
+          [maybe_reverse(face_symbol_info.reverse_columns_mode, line).join] * row_multiplicity
+        end
+      maybe_reverse(face_symbol_info.reverse_lines_mode, lines)
+    end
 
-      SKEWB_FACE_SIZE = 5
+    def simple_face_lines(cube_state, face_symbol, color_mode)
+      face_lines(cube_state, face_symbol) { |c| color_character(c, color_mode) }
+    end
 
-      def skewb_ascii_art_line(first_color, middle_color, last_color, num_first_color)
-        raise if num_first_color > SKEWB_FACE_SIZE / 2
+    SKEWB_FACE_SIZE = 5
 
-        first_color * num_first_color +
-          middle_color * (SKEWB_FACE_SIZE - 2 * num_first_color) +
-          last_color * num_first_color
-      end
+    def skewb_ascii_art_line(first_color, middle_color, last_color, num_first_color)
+      raise if num_first_color > SKEWB_FACE_SIZE / 2
 
-      def skewb_ascii_art(center_color, corner_colors)
-        raise unless corner_colors.length == 4
-
-        first_part =
-          (1..SKEWB_FACE_SIZE / 2).to_a.reverse.map do |i|
-            skewb_ascii_art_line(corner_colors[0], center_color, corner_colors[1], i)
-          end
-        middle_part = SKEWB_FACE_SIZE.odd? ? [center_color * SKEWB_FACE_SIZE] : []
-        last_part =
-          (1..SKEWB_FACE_SIZE / 2).map do |i|
-            skewb_ascii_art_line(corner_colors[2], center_color, corner_colors[3], i)
-          end
-        first_part + middle_part + last_part
-      end
+      first_color * num_first_color +
+        middle_color * (SKEWB_FACE_SIZE - 2 * num_first_color) +
+        last_color * num_first_color
+    end
 
-      # Prints a Skewb face like this:
-      # rrgww
-      # rgggw
-      # ggggg
-      # ogggb
-      # oogbb
-      def skewb_face_lines(cube_state, face_symbol, color_mode)
-        face = Face.for_face_symbol(face_symbol)
-        face_symbol_info = FACE_SYMBOL_INFOS[face_symbol]
-        stickers = cube_state.sticker_array(face)
-        center_color = color_character(stickers[0], color_mode)
-        corner_colors = stickers[1..-1].map { |c| color_character(c, color_mode) }
-        permuted_corner_colors =
-          apply_permutation(corner_colors, face_symbol_info.skewb_corner_permutation)
-        raise unless corner_colors.length == 4
-
-        skewb_ascii_art(center_color, permuted_corner_colors)
-      end
+    def skewb_ascii_art(center_color, corner_colors)
+      raise unless corner_colors.length == 4
 
-      def ll_string(cube_state, color_mode)
-        top_face = face_lines(cube_state, :U, 2, 3) { |c| color_character(c, color_mode) }
-        front_face = face_lines(cube_state, :F, 1, 3) { |c| color_character(c, color_mode) }
-        right_face = face_lines(cube_state, :R, 1, 3) { |c| color_character(c, color_mode) }
-        pll_line = front_face.first + right_face.first
-        (top_face + [pll_line] * 3).join("\n")
-      end
+      first_part =
+        (1..SKEWB_FACE_SIZE / 2).to_a.reverse.map do |i|
+          skewb_ascii_art_line(corner_colors[0], center_color, corner_colors[1], i)
+        end
+      middle_part = SKEWB_FACE_SIZE.odd? ? [center_color * SKEWB_FACE_SIZE] : []
+      last_part =
+        (1..SKEWB_FACE_SIZE / 2).map do |i|
+          skewb_ascii_art_line(corner_colors[2], center_color, corner_colors[3], i)
+        end
+      first_part + middle_part + last_part
+    end
 
-      def cube_string(cube_state, color_mode)
-        top_face = simple_face_lines(cube_state, :U, color_mode)
-        left_face = simple_face_lines(cube_state, :L, color_mode)
-        front_face = simple_face_lines(cube_state, :F, color_mode)
-        right_face = simple_face_lines(cube_state, :R, color_mode)
-        back_face = simple_face_lines(cube_state, :B, color_mode)
-        bottom_face = simple_face_lines(cube_state, :D, color_mode)
-        middle_belt = zip_concat_lines(left_face, front_face, right_face, back_face)
-        lines = pad_lines(top_face, cube_state.n) + middle_belt +
-                pad_lines(bottom_face, cube_state.n)
-        lines.join("\n")
-      end
+    # Prints a Skewb face like this:
+    # rrgww
+    # rgggw
+    # ggggg
+    # ogggb
+    # oogbb
+    def skewb_face_lines(cube_state, face_symbol, color_mode)
+      face = Face.for_face_symbol(face_symbol)
+      face_symbol_info = FACE_SYMBOL_INFOS[face_symbol]
+      stickers = cube_state.sticker_array(face)
+      center_color = color_character(stickers[0], color_mode)
+      corner_colors = stickers[1..].map { |c| color_character(c, color_mode) }
+      permuted_corner_colors =
+        apply_permutation(corner_colors, face_symbol_info.skewb_corner_permutation)
+      raise unless corner_colors.length == 4
+
+      skewb_ascii_art(center_color, permuted_corner_colors)
+    end
 
-      def skewb_string(skewb_state, color_mode)
-        top_face = skewb_face_lines(skewb_state, :U, color_mode)
-        left_face = skewb_face_lines(skewb_state, :L, color_mode)
-        front_face = skewb_face_lines(skewb_state, :F, color_mode)
-        right_face = skewb_face_lines(skewb_state, :R, color_mode)
-        back_face = skewb_face_lines(skewb_state, :B, color_mode)
-        bottom_face = skewb_face_lines(skewb_state, :D, color_mode)
-        middle_belt = zip_concat_lines(left_face, front_face, right_face, back_face)
-        lines = pad_lines(top_face, SKEWB_FACE_SIZE) + middle_belt +
-                pad_lines(bottom_face, SKEWB_FACE_SIZE)
-        lines.join("\n")
-      end
+    def ll_string(cube_state, color_mode)
+      top_face = face_lines(cube_state, :U, 2, 3) { |c| color_character(c, color_mode) }
+      front_face = face_lines(cube_state, :F, 1, 3) { |c| color_character(c, color_mode) }
+      right_face = face_lines(cube_state, :R, 1, 3) { |c| color_character(c, color_mode) }
+      pll_line = front_face.first + right_face.first
+      (top_face + [pll_line] * 3).join("\n")
+    end
 
-      def empty_name
-        ' '
-      end
+    def cube_string(cube_state, color_mode)
+      top_face = simple_face_lines(cube_state, :U, color_mode)
+      left_face = simple_face_lines(cube_state, :L, color_mode)
+      front_face = simple_face_lines(cube_state, :F, color_mode)
+      right_face = simple_face_lines(cube_state, :R, color_mode)
+      back_face = simple_face_lines(cube_state, :B, color_mode)
+      bottom_face = simple_face_lines(cube_state, :D, color_mode)
+      middle_belt = zip_concat_lines(left_face, front_face, right_face, back_face)
+      lines = pad_lines(top_face, cube_state.n) + middle_belt +
+              pad_lines(bottom_face, cube_state.n)
+      lines.join("\n")
+    end
 
-      def pad_lines(lines, padding)
-        lines.map { |line| empty_name * padding + line }
-      end
+    def skewb_string(skewb_state, color_mode)
+      top_face = skewb_face_lines(skewb_state, :U, color_mode)
+      left_face = skewb_face_lines(skewb_state, :L, color_mode)
+      front_face = skewb_face_lines(skewb_state, :F, color_mode)
+      right_face = skewb_face_lines(skewb_state, :R, color_mode)
+      back_face = skewb_face_lines(skewb_state, :B, color_mode)
+      bottom_face = skewb_face_lines(skewb_state, :D, color_mode)
+      middle_belt = zip_concat_lines(left_face, front_face, right_face, back_face)
+      lines = pad_lines(top_face, SKEWB_FACE_SIZE) + middle_belt +
+              pad_lines(bottom_face, SKEWB_FACE_SIZE)
+      lines.join("\n")
+    end
 
-      def zip_concat_lines(*args)
-        args.transpose.map(&:join)
-      end
+    def empty_name
+      ' '
+    end
+
+    def pad_lines(lines, padding)
+      lines.map { |line| empty_name * padding + line }
+    end
+
+    def zip_concat_lines(*args)
+      args.transpose.map(&:join)
     end
+  end
 end