twisty_puzzles 0.0.4 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9b1eef6907e1eced49a2341827ff269501861ba6bcd6e80f8b8a47be078cf2b
-  data.tar.gz: 954d9c2e59e038a4a65b4073ddad86669109bc5dabcf7b0f7b0efa26983156d0
+  metadata.gz: 3dfb23949825572c531ac7bfcea491151629f8673160605069b1793a827d961a
+  data.tar.gz: f343cc589e99ac129717f47a7b3dbe4dcb3d4a0cbcae2e0f8c42b12b22ad842c
 SHA512:
-  metadata.gz: ed59dd840b46359c2ab410325238d2634aede069afe1544df11a5c5adf2e99c6648f1776543d563ddc87937c9f73da7f185cc3ed2b52f0baf86a8c1419b89ccf
-  data.tar.gz: 6c67856ad23e2b99137d31c0a183c8b811caecf9f401215aecb6c58de3825e7754d9ba02aab6c275c37d511f7b5f4f90b5744e2318b91efb6f2ef24013c9976d
+  metadata.gz: 2fc20aef94e333318c53ee292b5418424ad8880cc2f8ff18c2102d0799d96728ccc9a98869269bf9c6a046174dcf5f71182cf6498021838d8772c18a7008cfe2
+  data.tar.gz: b79344d44bf6fd32cd9443c79405dcab052867a746e23fecc0b1496bd96b36fc6c4dd09d2a8c3d33389d7e5b5daaf0ca4a0552cce8948c59ac590da458c6150d

data/CHANGELOG.md

@@ -4,6 +4,10 @@ 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.5]
+### Changed
+- Now `require 'twisty_puzzles'` also requires the native extensions.
+
 ## [0.0.4]
 ### Fixed
 Fixed path in extconf.

data/README.md

@@ -1,3 +1,8 @@
+![Ruby](https://github.com/Lykos/twisty_puzzles/workflows/Ruby/badge.svg)
+![Rubocop](https://github.com/Lykos/twisty_puzzles/workflows/Rubocop/badge.svg)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Gem Version](https://badge.fury.io/rb/twisty_puzzles.svg)](https://badge.fury.io/rb/twisty_puzzles)
+
 # Twisty Puzzles
 Gem for my cube_trainer rails app. Some things are better left in a separate gem with no rails, e.g. native extensions. The main purpose is to support my Rails app, but if it's useful for someone else, feel free to use it at your own risk.
 
@@ -25,7 +30,7 @@ TODO: Write usage instructions here
 
 After checking out the repo, run `bundle install` to install dependencies. Then, run `bundle exec rake spec` to run the tests. You can also run `bundle exec bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `lib/twisty_puzzles/version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 

data/ext/twisty_puzzles/native/cube_algorithm.c

@@ -18,12 +18,12 @@ typedef struct {
   CubeMoveType type;
   face_index_t axis_face_index;
   direction_t direction;
-  size_t slice_index;
+  long slice_index;
 } CubeMove;
 
 typedef struct {
   size_t size;
-  size_t cube_size;
+  long cube_size;
   CubeMove* moves;
 } CubeAlgorithmData;
 
@@ -45,15 +45,6 @@ const rb_data_type_t CubeAlgorithmData_type = {
   RUBY_TYPED_FREE_IMMEDIATELY  
 };
 
-static void check_moves(const CubeAlgorithmData* const data, const char* const name) {
-  for (size_t i = 0; i < data->size; ++i) {
-    const CubeMoveType type = data->moves[i].type;
-    if (type != SLICE && type != FACE) {
-      rb_raise(rb_eRuntimeError, "invalid move type %d in %s", type, name);
-    }
-  }
-}
-
 static CubeMove* malloc_moves(const size_t n) {
   CubeMove* const moves = malloc(n * sizeof(CubeMove));
   if (moves == NULL) {
@@ -96,7 +87,7 @@ static CubeMoveType extract_move_type(const VALUE move_symbol) {
   }
 }
 
-static size_t components_for_move_type(const CubeMoveType type) {
+static long components_for_move_type(const CubeMoveType type) {
   switch (type) {
   case SLICE:
     return 4;
@@ -112,24 +103,25 @@ static VALUE CubeAlgorithm_initialize(const VALUE self, const VALUE cube_size, c
   CubeAlgorithmData* data;
   GetCubeAlgorithmData(self, data);
   data->size = RARRAY_LEN(moves);
-  data->cube_size = NUM2INT(cube_size);
+  data->cube_size = FIX2INT(cube_size);
+  check_cube_size(data->cube_size);
   data->moves = malloc_moves(data->size);
-  for (size_t i = 0; i < RARRAY_LEN(moves); ++i) {
+  for (long i = 0; i < RARRAY_LEN(moves); ++i) {
     const VALUE move = rb_ary_entry(moves, i);
     if (RARRAY_LEN(move) < 1) {
       rb_raise(rb_eArgError, "Moves cannot be empty.");
     }
     const CubeMoveType type = extract_move_type(rb_ary_entry(move, 0));
-    const size_t num_components = components_for_move_type(type);
+    const long num_components = components_for_move_type(type);
     if (RARRAY_LEN(move) != num_components) {
       rb_raise(rb_eArgError, "Moves with the given type need to have %ld elements. Got %ld.", num_components, RARRAY_LEN(move));
     }
     data->moves[i].type = type;
     data->moves[i].axis_face_index = face_index(rb_ary_entry(move, 1));
-    data->moves[i].direction = NUM2INT(rb_ary_entry(move, 2));
+    data->moves[i].direction = FIX2INT(rb_ary_entry(move, 2));
     if (type == SLICE) {
-      const size_t slice_index = NUM2INT(rb_ary_entry(move, 3));
-      if (slice_index >= data->cube_size) {
+      const long slice_index = FIX2INT(rb_ary_entry(move, 3));
+      if (slice_index < 0 || slice_index >= data->cube_size) {
         rb_raise(rb_eArgError, "Invalid slice index %ld for cube size %ld.", slice_index, data->cube_size);
       }
       data->moves[i].slice_index = slice_index;

data/ext/twisty_puzzles/native/cube_average.c

@@ -59,7 +59,7 @@ static VALUE CubeAverage_alloc(const VALUE klass) {
 
 static VALUE CubeAverage_initialize(const VALUE self, const VALUE capacity, const VALUE initial_average) {
   Check_Type(capacity, T_FIXNUM);
-  const size_t n = FIX2INT(capacity);
+  const long n = FIX2INT(capacity);
   if (n < 3) {
     rb_raise(rb_eArgError, "The number of elements for a cube average has to be at least 3. Got %ld.", n);
   }
@@ -147,7 +147,7 @@ static VALUE CubeAverage_push_all(const VALUE self, const VALUE new_values) {
   const size_t insert_index = data->insert_index;
   const size_t capacity = data->capacity;
   const size_t start = num_values > capacity ? num_values - capacity : 0;
-  for (size_t i = start; i < RARRAY_LEN(new_values); ++i) {
+  for (long i = start; i < RARRAY_LEN(new_values); ++i) {
     const VALUE new_value = rb_ary_entry(new_values, i);
     data->values[(insert_index + i) % capacity] = NUM2DBL(new_value);
   }

data/ext/twisty_puzzles/native/cube_coordinate.c

@@ -5,7 +5,7 @@
 static VALUE CubeCoordinateClass = Qnil;
 
 typedef struct {
-  size_t cube_size;
+  long cube_size;
   face_index_t on_face_index;
   Point point;
 } CubeCoordinateData;
@@ -26,15 +26,15 @@ const rb_data_type_t CubeCoordinateData_type = {
     TypedData_Get_Struct((obj), CubeCoordinateData, &CubeCoordinateData_type, (data)); \
   } while (0)
 
-size_t num_stickers(const size_t cube_size) {
+size_t num_stickers(const long cube_size) {
   return cube_faces * cube_size * cube_size;
 }
 
-size_t sticker_index(const size_t cube_size, const face_index_t on_face_index, const Point point) {
+size_t sticker_index(const long cube_size, const face_index_t on_face_index, const Point point) {
   return on_face_index * cube_size * cube_size + point.y * cube_size + point.x;
 }
 
-size_t CubeCoordinate_sticker_index(const VALUE self, const size_t cube_size) {
+size_t CubeCoordinate_sticker_index(const VALUE self, const long cube_size) {
   CubeCoordinateData* data;
   GetCubeCoordinateData(self, data);
   if (data->cube_size != cube_size) {
@@ -53,11 +53,11 @@ static VALUE CubeCoordinate_alloc(const VALUE klass) {
   return object;
 }
 
-static size_t inverted_index(const size_t cube_size, const size_t index) {
+static long inverted_index(const long cube_size, const long index) {
   return cube_size - 1 - index;
 }
 
-size_t transform_index(const face_index_t index_base_face_index, const size_t cube_size, const size_t index) {
+long transform_index(const face_index_t index_base_face_index, const long cube_size, const long index) {
   if (index_base_face_index == axis_index(index_base_face_index)) {
     return index;
   } else {
@@ -86,11 +86,11 @@ void check_base_face_indices(const face_index_t on_face_index,
 Point point_on_face(const face_index_t face_index,
                     const face_index_t x_base_face_index,
                     const face_index_t y_base_face_index,
-                    const size_t cube_size,
-                    const size_t untransformed_x,
-                    const size_t untransformed_y) {
-  const size_t transformed_x = transform_index(x_base_face_index, cube_size, untransformed_x);
-  const size_t transformed_y = transform_index(y_base_face_index, cube_size, untransformed_y);
+                    const long cube_size,
+                    const long untransformed_x,
+                    const long untransformed_y) {
+  const long transformed_x = transform_index(x_base_face_index, cube_size, untransformed_x);
+  const long transformed_y = transform_index(y_base_face_index, cube_size, untransformed_y);
   Point point;
   if (switch_axes(x_base_face_index, y_base_face_index)) {
     point.x = transformed_y;
@@ -102,7 +102,7 @@ Point point_on_face(const face_index_t face_index,
   return point;
 }
 
-static void check_cube_index(const size_t cube_size, const size_t index) {
+static void check_cube_index(const long cube_size, const long index) {
   if (index < 0 || index >= cube_size) {
     rb_raise(rb_eArgError, "Invalid value %ld for x with cube size %ld.", index, cube_size);
   }
@@ -121,14 +121,15 @@ static VALUE CubeCoordinate_initialize(const VALUE self,
   Check_Type(y_base_face_symbol, T_SYMBOL);
   Check_Type(x_num, T_FIXNUM);
   Check_Type(y_num, T_FIXNUM);
-  const size_t n = FIX2INT(cube_size);
+  const long n = FIX2INT(cube_size);
+  check_cube_size(n);
   const face_index_t on_face_index = face_index(face_symbol);
   const face_index_t x_base_face_index = face_index(x_base_face_symbol);
   const face_index_t y_base_face_index = face_index(y_base_face_symbol);
   check_base_face_indices(on_face_index, x_base_face_index, y_base_face_index);
-  const size_t untransformed_x = FIX2INT(x_num);
+  const long untransformed_x = FIX2INT(x_num);
   check_cube_index(n, untransformed_x);
-  const size_t untransformed_y = FIX2INT(y_num);
+  const long untransformed_y = FIX2INT(y_num);
   check_cube_index(n, untransformed_y);
   const Point point = point_on_face(on_face_index, x_base_face_index, y_base_face_index, n, untransformed_x, untransformed_y);
   CubeCoordinateData* data;

data/ext/twisty_puzzles/native/cube_coordinate.h

@@ -5,16 +5,16 @@
 #include "face_symbols.h"
 #include "utils.h"
 
-size_t num_stickers(size_t cube_size);
+size_t num_stickers(long cube_size);
 
 typedef struct {
   size_t x;
   size_t y;
 } Point;
 
-size_t sticker_index(size_t cube_size, face_index_t on_face_index, Point point);
+size_t sticker_index(long cube_size, face_index_t on_face_index, Point point);
 
-size_t transform_index(face_index_t index_base_face_index, size_t cube_size, size_t index);
+long transform_index(face_index_t index_base_face_index, long cube_size, long index);
 
 bool switch_axes(face_index_t x_base_face_index, face_index_t y_base_face_index);
 
@@ -25,10 +25,10 @@ void check_base_face_indices(face_index_t on_face_index,
 Point point_on_face(face_index_t on_face_index,
                     face_index_t x_base_face_index,
                     face_index_t y_base_face_index,
-                    size_t cube_size,
-                    size_t untransformed_x,
-                    size_t untransformed_y);
+                    long cube_size,
+                    long untransformed_x,
+                    long untransformed_y);
 
-size_t CubeCoordinate_sticker_index(VALUE self, size_t cube_size);
+size_t CubeCoordinate_sticker_index(VALUE self, long cube_size);
 
 void init_cube_coordinate_class_under(VALUE module);

data/ext/twisty_puzzles/native/cube_state.c

@@ -12,7 +12,7 @@ static VALUE CubeStateClass = Qnil;
 
 static void CubeStateData_mark(void* const ptr) {
   const CubeStateData* data = ptr;
-  const size_t n = data->cube_size;
+  const long n = data->cube_size;
   for (size_t i = 0; i < num_stickers(n); ++i) {
     rb_gc_mark(data->stickers[i]);
   }
@@ -52,19 +52,10 @@ static VALUE CubeState_alloc(const VALUE klass) {
   return object;
 }
 
-static size_t extract_index_base_face_index(const VALUE face_hash, const VALUE key) {
-  const VALUE index_base_face_symbol = rb_hash_aref(face_hash, key);
-  if (index_base_face_symbol == Qnil) {
-    rb_raise(rb_eTypeError, "Cube faces must have keys called :{x,y}_base_face_symbol that describes which face an x or y value of 0 is close to.");
-  }
-  Check_Type(index_base_face_symbol, T_SYMBOL);
-  return face_index(index_base_face_symbol);
-}
-
 static int CubeState_replace_face(const VALUE key, const VALUE value, const VALUE self) {
   const CubeStateData* data;
   GetInitializedCubeStateData(self, data);
-  const size_t n = data->cube_size;
+  const long n = data->cube_size;
   Check_Type(value, T_HASH);
   if (RHASH_SIZE(value) != 3) {
     rb_raise(rb_eTypeError, "Cube faces must have 3 entries, got %ld.", RHASH_SIZE(value));
@@ -75,19 +66,17 @@ static int CubeState_replace_face(const VALUE key, const VALUE value, const VALU
   if (stickers == Qnil) {
     rb_raise(rb_eTypeError, "Cube faces must have a key called :stickers that contains the stickers on that face.");
   }
-  const face_index_t x_base_face_index = extract_index_base_face_index(value, ID2SYM(x_base_face_symbol_id));
-  const face_index_t y_base_face_index = extract_index_base_face_index(value, ID2SYM(y_base_face_symbol_id));
   Check_Type(stickers, T_ARRAY);
   if (RARRAY_LEN(stickers) != n) {
       rb_raise(rb_eArgError, "All faces of a %ldx%ld cube must have %ld rows. Got %ld rows.", n, n, n, RARRAY_LEN(stickers));
   }
-  for (size_t y = 0; y < n; ++y) {
+  for (long y = 0; y < n; ++y) {
     const VALUE row = rb_ary_entry(stickers, y);
     Check_Type(row, T_ARRAY);
     if (RARRAY_LEN(row) != n) {
       rb_raise(rb_eArgError, "All rows of a %ldx%ld cube must have %ld cells. Got %ld cells.", n, n, n, RARRAY_LEN(row));
     }
-    for (size_t x = 0; x < n; ++x) {
+    for (long x = 0; x < n; ++x) {
       const VALUE cell = rb_ary_entry(row, x);
       Point point = {x, y};
       data->stickers[sticker_index(n, on_face_index, point)] = cell;
@@ -99,7 +88,8 @@ static int CubeState_replace_face(const VALUE key, const VALUE value, const VALU
 static VALUE CubeState_initialize(const VALUE self, const VALUE cube_size, const VALUE stickers) {
   Check_Type(cube_size, T_FIXNUM);
   Check_Type(stickers, T_HASH);
-  const size_t n = FIX2INT(cube_size);
+  const long n = FIX2INT(cube_size);
+  check_cube_size(n);
   CubeStateData* data;
   GetCubeStateData(self, data);
   data->cube_size = n;
@@ -127,11 +117,11 @@ static VALUE CubeState_sticker_array(const VALUE self,
   check_base_face_indices(on_face_index, x_base_face_index, y_base_face_index);
   const CubeStateData* data;
   GetInitializedCubeStateData(self, data);
-  const size_t n = data->cube_size;
+  const long n = data->cube_size;
   const VALUE face = rb_ary_new2(n);
-  for (size_t y = 0; y < n; ++y) {
+  for (long y = 0; y < n; ++y) {
     const VALUE row = rb_ary_new2(n);
-    for (size_t x = 0; x < n; ++x) {
+    for (long x = 0; x < n; ++x) {
       const Point point = point_on_face(on_face_index, x_base_face_index, y_base_face_index, n, x, y);
       const VALUE cell = data->stickers[sticker_index(n, on_face_index, point)];
       rb_ary_store(row, x, cell);
@@ -159,7 +149,7 @@ static VALUE CubeState_hash(const VALUE self) {
 
   st_index_t hash = rb_hash_start(data->cube_size);
   hash = rb_hash_uint(hash, (st_index_t)CubeState_hash);
-  const size_t n = data->cube_size;
+  const long n = data->cube_size;
   for (size_t i = 0; i < num_stickers(n); i++) {
     const VALUE sub_hash = rb_hash(data->stickers[i]);
     hash = rb_hash_uint(hash, NUM2LONG(sub_hash));
@@ -181,7 +171,7 @@ static VALUE CubeState_eql(const VALUE self, const VALUE other) {
   if (self_data->cube_size != other_data->cube_size) {
     return Qfalse;
   }
-  const size_t n = self_data->cube_size;
+  const long n = self_data->cube_size;
   for (size_t i = 0; i < num_stickers(n); ++i) {
     if (!color_eq(self_data->stickers[i], other_data->stickers[i])) {
       return Qfalse;
@@ -193,7 +183,7 @@ static VALUE CubeState_eql(const VALUE self, const VALUE other) {
 static VALUE CubeState_dup(const VALUE self) {
   const CubeStateData* data;
   GetInitializedCubeStateData(self, data);
-  const size_t n = data->cube_size;
+  const long n = data->cube_size;
   CubeStateData* dupped_data;
   const VALUE dupped = TypedData_Make_Struct(rb_obj_class(self), CubeStateData, &CubeStateData_type, dupped_data);
   dupped_data->cube_size = n;
@@ -208,19 +198,19 @@ static VALUE CubeState_cube_size(const VALUE self) {
   return ST2FIX(data->cube_size);
 }
 
-void rotate_slice_for_cube(const face_index_t turned_face_index, const size_t slice_index, direction_t direction, const CubeStateData* const data) {
+void rotate_slice_for_cube(const face_index_t turned_face_index, const long slice_index, direction_t direction, const CubeStateData* const data) {
   direction = CROP_MOD(direction, 4);
   if (direction == 0) {
     return;
   }
-  const size_t n = data->cube_size;
-  for (size_t i = 0; i < n; ++i) {
+  const long n = data->cube_size;
+  for (long x = 0; x < n; ++x) {
     Sticker4Cycle cycle;
-    for (size_t j = 0; j < neighbor_faces; ++j) {
-      const face_index_t on_face_index = neighbor_face_index(turned_face_index, j);
-      const face_index_t next_face_index = neighbor_face_index(turned_face_index, j + 1);
-      const Point point = point_on_face(on_face_index, turned_face_index, next_face_index, n, slice_index, i);
-      cycle.indices[j] = sticker_index(n, on_face_index, point);
+    for (size_t i = 0; i < neighbor_faces; ++i) {
+      const face_index_t on_face_index = neighbor_face_index(turned_face_index, i);
+      const face_index_t next_face_index = neighbor_face_index(turned_face_index, i + 1);
+      const Point point = point_on_face(on_face_index, turned_face_index, next_face_index, n, slice_index, x);
+      cycle.indices[i] = sticker_index(n, on_face_index, point);
     }
     apply_sticker_4cycle(data->stickers, cycle, direction);
   }  
@@ -231,9 +221,9 @@ void rotate_face_for_cube(const face_index_t turned_face_index, direction_t dire
   if (direction == 0) {
     return;
   }
-  const size_t n = data->cube_size;
-  for (size_t y = 0; y < n / 2; ++y) {
-    for (size_t x = 0; x < (n + 1) / 2; ++x) {
+  const long n = data->cube_size;
+  for (long y = 0; y < n / 2; ++y) {
+    for (long x = 0; x < (n + 1) / 2; ++x) {
       Sticker4Cycle cycle;
       for (size_t j = 0; j < neighbor_faces; ++j) {
         const face_index_t x_face_index = neighbor_face_index(turned_face_index, j);

data/ext/twisty_puzzles/native/cube_state.h

@@ -5,7 +5,7 @@
 #include "face_symbols.h"
 
 typedef struct {
-  size_t cube_size;
+  long cube_size;
   VALUE* stickers;
 } CubeStateData;
 
@@ -24,7 +24,7 @@ extern const rb_data_type_t CubeStateData_type;
     } \
   } while(0)
 
-void rotate_slice_for_cube(face_index_t turned_face_index, size_t slice_index, direction_t direction, const CubeStateData* data);
+void rotate_slice_for_cube(face_index_t turned_face_index, long slice_index, direction_t direction, const CubeStateData* data);
 
 void rotate_face_for_cube(face_index_t turned_face_index, direction_t direction, const CubeStateData* data);
 

data/ext/twisty_puzzles/native/face_symbols.h

@@ -4,8 +4,8 @@
 
 #include "utils.h"
 
-typedef char face_index_t;
-typedef char axis_index_t;
+typedef unsigned char face_index_t;
+typedef unsigned char axis_index_t;
 
 #define cube_faces 6
 #define neighbor_faces 4

data/ext/twisty_puzzles/native/skewb_algorithm.c

@@ -50,15 +50,6 @@ const rb_data_type_t SkewbAlgorithmData_type = {
   RUBY_TYPED_FREE_IMMEDIATELY  
 };
 
-static void check_moves(const SkewbAlgorithmData* const data, const char* const name) {
-  for (size_t i = 0; i < data->size; ++i) {
-    const SkewbMoveType type = data->moves[i].type;
-    if (type != MOVE && type != ROTATION) {
-      rb_raise(rb_eRuntimeError, "invalid move type %d in %s", type, name);
-    }
-  }
-}
-
 static SkewbMove* malloc_moves(const size_t n) {
   SkewbMove* const moves = malloc(n * sizeof(SkewbMove));
   if (moves == NULL) {
@@ -122,7 +113,7 @@ static VALUE SkewbAlgorithm_initialize(const VALUE self, const VALUE moves) {
   data->size = RARRAY_LEN(moves);
   data->initialized = TRUE;
   data->moves = malloc_moves(data->size);
-  for (size_t i = 0; i < RARRAY_LEN(moves); ++i) {
+  for (long i = 0; i < RARRAY_LEN(moves); ++i) {
     const VALUE move = rb_ary_entry(moves, i);
     if (RARRAY_LEN(move) != 3) {
       rb_raise(rb_eArgError, "Moves must have 3 elements. Got %ld.", RARRAY_LEN(moves));
@@ -171,8 +162,8 @@ static face_index_t axis_face_on_corner(const Corner corner, const face_index_t
 
 bool corners_eq(Corner left, Corner right) {
   return left.face_indices[0] == right.face_indices[0] &&
-    (left.face_indices[1] == right.face_indices[1] && left.face_indices[2] == right.face_indices[2] ||
-     left.face_indices[1] == right.face_indices[2] && left.face_indices[2] == right.face_indices[1]);
+    ((left.face_indices[1] == right.face_indices[1] && left.face_indices[2] == right.face_indices[2]) ||
+     (left.face_indices[1] == right.face_indices[2] && left.face_indices[2] == right.face_indices[1]));
 }
 
 size_t equivalent_corner_index(const FaceCorners corners, const Corner corner) {  

data/ext/twisty_puzzles/native/skewb_coordinate.c

@@ -56,17 +56,6 @@ size_t center_sticker_index(const face_index_t on_face_index) {
   return on_face_index * skewb_stickers_per_face;
 }
 
-static VALUE part_type_from_symbol(const VALUE part_type_symbol) {
-  Check_Type(face_symbol, T_SYMBOL);
-  if (SYM2ID(part_type_symbol) == center_part_type_id) {
-    return CENTER;
-  } else if (SYM2ID(part_type_symbol) == corner_part_type_id) {
-    return CORNER;
-  } else {
-    rb_raise(rb_eArgError, "Invalid part type symbol %+"PRIsVALUE"", part_type_symbol);
-  }
-}
-
 static VALUE part_type_to_symbol(const SkewbPartType part_type) {
   // Caching these keys isn't easy because the garbage collector will get them.
   switch (part_type) {

data/ext/twisty_puzzles/native/skewb_layer_fingerprint.c

@@ -32,7 +32,7 @@ static ID times = 848;
 
 typedef struct {
   Corner corner_pairs[max_corner_pair_group_size][2];
-  int num_corner_pairs;
+  size_t num_corner_pairs;
   // Number of different group fingerprints. This can be used to merge several group fingerprints.
   int num_group_fingerprints;
 } CornerPairGroup;
@@ -55,7 +55,7 @@ static bool has_color_at(const ActualCornerStickers actual, const size_t index,
 }
 
 typedef struct {
-  int layer_index;
+  size_t layer_index;
   bool is_oriented;
   bool is_present;
 } ActualCornerStickersInfo;
@@ -268,4 +268,5 @@ void init_skewb_layer_fingerprint_method_under(const VALUE module) {
   plus = rb_intern("+");
   times = rb_intern("*");
   rb_define_singleton_method(module, "skewb_layer_fingerprint", skewb_layer_fingerprint, 2);
+  init_corner_pair_groups();
 }

data/ext/twisty_puzzles/native/skewb_state.c

@@ -43,8 +43,6 @@ static int SkewbState_replace_face(const VALUE key, const VALUE value, const VAL
 
 static VALUE SkewbState_initialize(const VALUE self, const VALUE stickers) {
   Check_Type(stickers, T_HASH);
-  SkewbStateData* data;
-  GetSkewbStateData(self, data);
   if (RHASH_SIZE(stickers) != skewb_faces) {
     rb_raise(rb_eTypeError, "Skewbs must have %d faces. Got %ld.", skewb_faces, RHASH_SIZE(stickers));
   }

data/ext/twisty_puzzles/native/utils.c

@@ -64,7 +64,7 @@ int log2_64_floor(uint64_t value) {
     return tab64[((uint64_t)((value - (value >> 1))*0x07EDD5E59A4E28C2)) >> 58];
 }
 
-uint64_t iexp(const uint64_t base, uint32_t exp) {
+uint64_t iexp(const uint64_t base, const uint32_t exp) {
   uint64_t result = 1;
   for (uint32_t m = 1 << 31; m; m >>= 1) {
     result = result * result;
@@ -74,3 +74,9 @@ uint64_t iexp(const uint64_t base, uint32_t exp) {
   }
   return result;
 }
+
+void check_cube_size(const long cube_size) {
+  if (cube_size <= 0) {
+    rb_raise(rb_eArgError, "Cube size must be positive. Got %ld.", cube_size);
+  }
+}

data/ext/twisty_puzzles/native/utils.h

@@ -5,11 +5,8 @@
 
 #define MIN(a, b) ((a) > (b) ? (b) : (a))
 #define MAX(a, b) ((a) > (b) ? (a) : (b))
-#define FALSE 0
-#define TRUE 1
 #define CROP_MOD(a, b) (((a) % (b) + (b)) % (b))
 
-typedef char bool;
 typedef char direction_t;
 
 typedef struct {
@@ -29,3 +26,5 @@ int color_eq(VALUE left, VALUE right);
 int log2_64_floor(uint64_t value);
 
 uint64_t iexp(uint64_t base, uint32_t exp);
+
+void check_cube_size(long cube_size);

data/lib/twisty_puzzles.rb

@@ -22,6 +22,7 @@ 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/native'
 require 'twisty_puzzles/parser'
 require 'twisty_puzzles/part_cycle_factory'
 require 'twisty_puzzles/puzzle'

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

@@ -20,7 +20,7 @@ module TwistyPuzzles
     end
 
     def parse_named_captures(match)
-      present_named_captures = match.named_captures.reject { |_n, v| v.nil? }
+      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)

data/lib/twisty_puzzles/algorithm.rb

@@ -128,7 +128,7 @@ module TwistyPuzzles
       AbstractMove.check_move_metric(metric)
       return 0 if empty?
 
-      @moves.map { |m| m.move_count(cube_size, metric) }.reduce(:+)
+      @moves.sum { |m| m.move_count(cube_size, metric) }
     end
 
     def *(other)

data/lib/twisty_puzzles/axis_face_and_direction_move.rb

@@ -11,6 +11,7 @@ module TwistyPuzzles
       raise TypeError, "Unsuitable axis face #{axis_face}." unless axis_face.is_a?(Face)
       raise TypeError unless direction.is_a?(CubeDirection)
 
+      super()
       @axis_face = axis_face
       @direction = direction
     end

data/lib/twisty_puzzles/cancellation_helper.rb

@@ -135,7 +135,7 @@ module TwistyPuzzles
     def self.alg_plus_cancelled_move(algorithm, move, cube_size)
       if move.is_a?(Rotation) && (tail_rotations = num_tail_rotations(algorithm)) >= 2
         Algorithm.new(algorithm.moves[0...-tail_rotations]) +
-          cancelled_rotations(algorithm.moves[-tail_rotations..-1] + [move])
+          cancelled_rotations(algorithm.moves[-tail_rotations..] + [move])
       else
         Algorithm.new(algorithm.moves[0...-1]) +
           algorithm.moves[-1].join_with_cancellation(move, cube_size)

data/lib/twisty_puzzles/color_scheme.rb

@@ -56,7 +56,7 @@ module TwistyPuzzles
       raise ArgumentError unless colors.include?(top_color)
       raise ArgumentError unless colors.include?(front_color)
 
-      # Note: The reason that this is so complicated is that we want it to still work if the
+      # NOTE: The reason that this is so complicated is that we want it to still work if the
       # chirality corner gets exchanged.
 
       # Do the obvious and handle opposites of the top and front color so we have no

data/lib/twisty_puzzles/commutator.rb

@@ -17,6 +17,7 @@ module TwistyPuzzles
     def initialize(algorithm)
       raise ArgumentError unless algorithm.is_a?(Algorithm)
 
+      super()
       @algorithm = algorithm
     end
 
@@ -47,6 +48,7 @@ module TwistyPuzzles
       raise ArgumentError unless first_part.is_a?(Algorithm)
       raise ArgumentError unless second_part.is_a?(Algorithm)
 
+      super()
       @first_part = first_part
       @second_part = second_part
     end
@@ -85,6 +87,7 @@ module TwistyPuzzles
         raise ArgumentError, 'Inner commutator has to be a commutator.'
       end
 
+      super()
       @setup = setup
       @inner_commutator = inner_commutator
     end

data/lib/twisty_puzzles/compiled_algorithm.rb

@@ -26,10 +26,10 @@ module TwistyPuzzles
     def inverse
       @inverse ||=
         begin
-                              alg = self.class.new(@native.inverse)
-                              alg.inverse = self
-                              alg
-                            end
+          alg = self.class.new(@native.inverse)
+          alg.inverse = self
+          alg
+        end
     end
 
     def +(other)

data/lib/twisty_puzzles/coordinate.rb

@@ -6,6 +6,7 @@ require 'twisty_puzzles/native'
 
 module TwistyPuzzles
   # Coordinate of a sticker on the cube.
+  # rubocop:disable  Metrics/ClassLength
   class Coordinate
     def self.highest_coordinate(cube_size)
       cube_size - 1
@@ -90,7 +91,7 @@ module TwistyPuzzles
       base_coordinate = Coordinate.from_indices(
         part.solved_face, cube_size, *part.base_index_on_face(cube_size, incarnation_index)
       )
-      other_face_symbols = part.corresponding_part.face_symbols[1..-1]
+      other_face_symbols = part.corresponding_part.face_symbols[1..]
       match_coordinate_internal(base_coordinate, other_face_symbols)
     end
 
@@ -99,7 +100,7 @@ module TwistyPuzzles
     def self.solved_positions(part, cube_size, incarnation_index)
       solved_coordinate = solved_position(part, cube_size, incarnation_index)
       other_coordinates =
-        part.face_symbols[1..-1].map.with_index do |f, i|
+        part.face_symbols[1..].map.with_index do |f, i|
           face = Face.for_face_symbol(f)
           # The reverse is important for edge like parts. We are not in the same position as usual
           # solved pieces would be.
@@ -109,7 +110,7 @@ module TwistyPuzzles
           base_coordinate = Coordinate.from_indices(face, cube_size, *base_indices)
           other_face_symbols = [part.face_symbols[0]] +
                                part.corresponding_part.face_symbols[1...i + 1] +
-                               part.corresponding_part.face_symbols[i + 2..-1]
+                               part.corresponding_part.face_symbols[i + 2..]
           match_coordinate_internal(base_coordinate, other_face_symbols)
         end
       [solved_coordinate] + other_coordinates
@@ -121,6 +122,23 @@ module TwistyPuzzles
       from_indices(face, cube_size, m, m)
     end
 
+    def self.face(face, cube_size)
+      neighbor_a, neighbor_b = face.neighbors[0..1]
+      coordinate_range(cube_size).collect_concat do |x|
+        coordinate_range(cube_size).map do |y|
+          from_face_distances(face, cube_size, neighbor_a => x, neighbor_b => y)
+        end
+      end
+    end
+
+    def self.layer(face, cube_size)
+      face.neighbors.zip(face.neighbors.rotate(1)).collect_concat do |neighbor, next_neighbor|
+        coordinate_range(cube_size).map do |i|
+          from_face_distances(neighbor, cube_size, face => 0, next_neighbor => i)
+        end
+      end + self.face(face, cube_size)
+    end
+
     def self.edges_outside(face, cube_size)
       face.neighbors.zip(face.neighbors.rotate(1)).collect_concat do |neighbor, next_neighbor|
         1.upto(cube_size - 2).map do |i|
@@ -261,6 +279,7 @@ module TwistyPuzzles
       rots
     end
   end
+  # rubocop:enable Metrics/ClassLength
 
   # Coordinate of a sticker on the Skewb.
   class SkewbCoordinate
@@ -276,7 +295,7 @@ module TwistyPuzzles
       @native = native
     end
 
-    attr_reader :native
+    attr_reader :native, :coordinate
 
     private_class_method :new
 
@@ -311,7 +330,5 @@ module TwistyPuzzles
     def face
       @face ||= Face.for_face_symbol(@native.face)
     end
-
-    attr_reader :coordinate
   end
 end

data/lib/twisty_puzzles/cube.rb

@@ -97,7 +97,7 @@ module TwistyPuzzles
     end
 
     def inspect
-      self.class.to_s + '(' + @face_symbols.map(&:to_s).join(', ') + ')'
+      "#{self.class}(#{@face_symbols.map(&:to_s).join(', ')})"
     end
 
     def to_s
@@ -365,7 +365,7 @@ module TwistyPuzzles
     attr_reader :corresponding_part
 
     def inspect
-      self.class.to_s + '(' + face_symbol.to_s + ', ' + @corresponding_part.inspect + ')'
+      "#{self.class}(#{face_symbol}, #{@corresponding_part.inspect})"
     end
 
     def rotate_by(_number)
@@ -532,7 +532,7 @@ module TwistyPuzzles
 
     def self.create_for_face_symbols(face_symbols)
       piece_candidates =
-        face_symbols[1..-1].permutation.map do |cs|
+        face_symbols[1..].permutation.map do |cs|
           new([face_symbols[0]] + cs)
         end
       find_only(piece_candidates, &:valid?)

data/lib/twisty_puzzles/cube_move.rb

@@ -139,8 +139,6 @@ module TwistyPuzzles
       end
     end
 
-    # rubocop:disable Metrics/PerceivedComplexity
-    # rubocop:disable Metrics/CyclomaticComplexity
     def prepend_fat_move(other, cube_size)
       if same_fat_block?(other)
         merge_with_same_fat_block(other)
@@ -156,8 +154,6 @@ module TwistyPuzzles
         Algorithm.move(other.inner_fat_mslice_move(cube_size))
       end
     end
-    # rubocop:enable Metrics/CyclomaticComplexity
-    # rubocop:enable Metrics/PerceivedComplexity
 
     def prepend_slice_move(other, cube_size)
       return unless same_axis?(other)

data/lib/twisty_puzzles/cube_move_parser.rb

@@ -14,29 +14,29 @@ module TwistyPuzzles
   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
+        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),

data/lib/twisty_puzzles/cube_print_helper.rb

@@ -41,9 +41,10 @@ module TwistyPuzzles
     end
 
     def maybe_reverse(reverse_mode, stuff)
-      if reverse_mode == :reverse
+      case reverse_mode
+      when :reverse
         stuff.reverse
-      elsif reverse_mode == :keep
+      when :keep
         stuff
       else
         raise
@@ -102,7 +103,7 @@ module TwistyPuzzles
       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) }
+      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

data/lib/twisty_puzzles/parser.rb

@@ -185,14 +185,14 @@ module TwistyPuzzles # rubocop:disable Style/Documentation
     end
   end
 
-  def parse_commutator(alg_string, complete_parse = true)
+  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)
+  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
@@ -206,7 +206,7 @@ module TwistyPuzzles # rubocop:disable Style/Documentation
   alias parse_algorithm parse_cube_algorithm
   alias parse_move parse_cube_move
 
-  def parse_skewb_algorithm(alg_string, notation, complete_parse = true)
+  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

data/lib/twisty_puzzles/rotation.rb

@@ -62,6 +62,7 @@ module TwistyPuzzles
       [self, alternative].include?(other)
     end
 
+    # rubocop:disable Metrics/AbcSize
     def prepend_rotation(other, _cube_size)
       if same_axis?(other)
         direction = translated_direction(other.axis_face)
@@ -74,6 +75,7 @@ module TwistyPuzzles
         Algorithm.move(Rotation.new(remaining_face, CubeDirection::DOUBLE))
       end
     end
+    # rubocop:enable Metrics/AbcSize
 
     def prepend_fat_m_slice_move(_other, _cube_size)
       nil

data/lib/twisty_puzzles/skewb_move.rb

@@ -12,6 +12,7 @@ module TwistyPuzzles
       raise TypeError unless axis_corner.is_a?(Corner)
       raise TypeError unless direction.is_a?(SkewbDirection)
 
+      super()
       @axis_corner = axis_corner.rotate_face_up(axis_corner.faces.min_by(&:piece_index))
       @direction = direction
     end

data/lib/twisty_puzzles/skewb_move_parser.rb

@@ -18,6 +18,7 @@ module TwistyPuzzles
     def initialize(notation)
       raise TypeError unless notation.is_a?(SkewbNotation)
 
+      super()
       @notation = notation
     end
 

data/lib/twisty_puzzles/skewb_notation.rb

@@ -10,9 +10,11 @@ module TwistyPuzzles
   # Class that represents one notation for Skewb moves, e.g. Sarahs notation or fixed
   # corner notation.
   class SkewbNotation
+    # rubocop:disable Metrics/AbcSize
     def initialize(name, move_corner_pairs)
       raise TypeError unless name.is_a?(String)
 
+      super()
       check_move_corner_pairs(move_corner_pairs)
       @name = name
       @move_to_corner = move_corner_pairs.to_h.freeze
@@ -26,7 +28,9 @@ module TwistyPuzzles
         end.freeze
       freeze
     end
+    # rubocop:enable Metrics/AbcSize
 
+    # rubocop:disable Metrics/CyclomaticComplexity
     def check_move_corner_pairs(move_corner_pairs)
       move_corner_pairs.each do |m|
         raise ArgumentError unless m.length == 2
@@ -37,6 +41,7 @@ module TwistyPuzzles
 
       check_corner_coverage(move_corner_pairs.map(&:last))
     end
+    # rubocop:enable Metrics/CyclomaticComplexity
 
     def check_corner_coverage(corners)
       corner_closure = corners + corners.map(&:diagonal_opposite)
@@ -49,6 +54,7 @@ module TwistyPuzzles
     end
 
     attr_reader :name, :move_strings, :non_zero_moves
+
     private_class_method :new
 
     def self.fixed_corner
@@ -103,7 +109,7 @@ module TwistyPuzzles
         move_to_string(m, reversed_rotations)
       end.join(' ')
       new_tail_rotations = reversed_rotations.reverse! +
-                           algorithm.moves[algorithm.length - num_tail_rotations..-1]
+                           algorithm.moves[algorithm.length - num_tail_rotations..]
       cancelled_rotations = Algorithm.new(new_tail_rotations).cancelled(3)
       cancelled_rotations.empty? ? alg_string : "#{alg_string} #{cancelled_rotations}"
     end

data/lib/twisty_puzzles/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TwistyPuzzles
-  VERSION = '0.0.4'
+  VERSION = '0.0.9'
 end

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: twisty_puzzles
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.9
 platform: ruby
 authors:
 - Bernhard F. Brodowsky
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
 date: 2020-04-21 00:00:00.000000000 Z
@@ -112,16 +112,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
@@ -164,7 +164,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email: bernhard.brodowsky@gmail.com
 executables: []
 extensions:
@@ -245,7 +245,7 @@ metadata:
   homepage_uri: https://github.com/Lykos/twisty_puzzles
   source_code_uri: https://github.com/Lykos/twisty_puzzles
   changelog_uri: https://github.com/Lykos/twisty_puzzles/blob/master/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -253,16 +253,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Gem for my cube_trainer rails app. Some things are better left in a separate
   gem with no rails, e.g. native extensions. The main purpose is to support my Rails