twisty_puzzles 0.0.5 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6328e75fef53854e6be5c5f5cbe3eb27e775b2b97397731ee6547291126fa94
-  data.tar.gz: fc78c670139d170a18aa1f89854520ba00596ba4078b65dc4572a3c6d4ee4b9e
+  metadata.gz: 7616a5e5bd64a5beb6ea98bed6a6f6bc2dc5ae145491db533e4693cd10d0ff6d
+  data.tar.gz: 8bc2cd597844fb86f9168c8e368c6bbb01cc34a82598ebef7f5dcb77c1e3713c
 SHA512:
-  metadata.gz: 31ac0e826d8011114db4edcd88a87c52d47dc7ca925c51533c4262869e361608ed935f907342cb8d41145086086798bd837aaf1ae4e7bc509282f070f4c03d86
-  data.tar.gz: 1cb3ed5deb0a2bcdfd5e3ae469c4ad8e701504da2ab222eff4fa24c8f2b10413a8f96ee356b91c514846f8c416744e4f7ae90a8d6135ff9cf8fd4e1b6cdbcff5
+  metadata.gz: 42c3be051514680426bed25b66ca09b8c420f1423a778db10512c37663c42128136acf6f4e72847bed68d4111e8563ef5eb1cd427883bf2802e072853f1900b0
+  data.tar.gz: d26d1c98f90f7bbd15474ac45f200a483983daadfae40016e5f9d2f0ca44b20a652e480f8bbfc13d939f904140358a1acc741fcbbb09306f35b51a298f3a9cf1

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) {