twisty_puzzles 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4c23d462856d3827fe5386ca3d4d3816c2ce37cf6e06eb3876a9e4b18c4aef36
+  data.tar.gz: 561a871d7287fde1d568a00b243dff15337c0ae785c3caa55e71a2e94a0d09a0
+SHA512:
+  metadata.gz: b944ba73e3cf1c4cad55156237fd4c9a87888796ea5e6fbff6606c36a9d97b84a59e1c85a42318e70c71848399205dd117c8385a01d592be6f2bdbcdaeef3570
+  data.tar.gz: 41894ab27afc69dffef137acb506819be9d94b3b27b339ba3ff1bc75731736575f412609a7e127920d60c9c5954f808ef98deafee6ec27f23856f1e794f67fdd

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+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.1]
+### Added
+Split off core twisty puzzles functionality from cube_trainer repo into a Gem.

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project owner at bernhard.brodowsky@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project owner is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Bernhard F. Brodowsky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,32 @@
+# 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.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'twisty_puzzles'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install twisty_puzzles
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+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).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Lykos/twisty_puzzles.

data/ext/twisty_puzzles/native/extconf.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+
+create_makefile('native')

data/lib/twisty_puzzles/abstract_direction.rb

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

data/lib/twisty_puzzles/abstract_move.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/algorithm'
+require 'twisty_puzzles/cube'
+require 'twisty_puzzles/utils/string_helper'
+require 'twisty_puzzles/utils/array_helper'
+
+module TwistyPuzzles
+  # Base class for moves.
+  class AbstractMove
+    include Comparable
+    include Utils::StringHelper
+    include Utils::ArrayHelper
+    AXES = %w[y z x].freeze
+    # rubocop:disable Style/StringHashKeys
+    SLICE_FACES = { 'E' => Face::D, 'S' => Face::F, 'M' => Face::L }.freeze
+    # rubocop:enable Style/StringHashKeys
+    SLICE_NAMES = SLICE_FACES.invert.freeze
+    MOVE_METRICS = %i[qtm htm stm sqtm qstm].freeze
+
+    def <=>(other)
+      [self.class.name] + identifying_fields <=> [other.class.name] + other.identifying_fields
+    end
+
+    def hash
+      @hash ||= ([self.class] + identifying_fields).hash
+    end
+
+    def eql?(other)
+      self.class == other.class && identifying_fields == other.identifying_fields
+    end
+
+    alias == eql?
+
+    def identifying_fields
+      raise NotImplementedError
+    end
+
+    def inverse
+      fields = replace_once(identifying_fields, direction, direction.inverse)
+      self.class.new(*fields)
+    end
+
+    def identity?
+      direction.zero?
+    end
+
+    def self.check_move_metric(metric)
+      raise ArgumentError, "Invalid move metric #{metric}." unless MOVE_METRICS.include?(metric)
+    end
+
+    def equivalent?(other, cube_size)
+      decide_meaning(cube_size).equivalent_internal?(other.decide_meaning(cube_size), cube_size)
+    end
+
+    def equivalent_internal?(other, _cube_size)
+      self == other
+    end
+
+    def can_swap?(other)
+      is_a?(Rotation) || other.is_a?(Rotation)
+    end
+
+    # For moves A, B, returns [C, D] if they can be swapped.
+    def swap(other)
+      raise ArgumentError unless can_swap?(other)
+
+      if is_a?(Rotation)
+        [other.rotate_by(inverse), self]
+      elsif other.is_a?(Rotation)
+        [other, rotate_by(other)]
+      else
+        swap_internal(other)
+      end
+    end
+
+    def swap_internal(other)
+      raise NotImplementedError,
+            "Not implemented for #{self}:#{self.class} and #{other}:#{other.class}."
+    end
+
+    # Cube size is needed to decide whether 'u' is a slice move (like on bigger cubes) or a fat
+    # move (like on 3x3).
+    def move_count(cube_size, metric = :htm)
+      raise TypeError unless cube_size.is_a?(Integer)
+
+      AbstractMove.check_move_metric(metric)
+      return 0 if direction.zero?
+
+      slice_factor = decide_meaning(cube_size).slice_move? ? 2 : 1
+      direction_factor = direction.double_move? ? 2 : 1
+      move_count_internal(metric, slice_factor, direction_factor)
+    end
+
+    def slice_move?
+      raise NotImplementedError, "Not implemented for #{self}:#{self.class}."
+    end
+
+    def direction
+      raise NotImplementedError
+    end
+
+    def rotate_by(_rotation)
+      raise NotImplementedError
+    end
+
+    def mirror(_normal_face)
+      raise NotImplementedError
+    end
+
+    # The superclass for all moves that work on the same type puzzle as the given one
+    # (modulo cube size, i.e. 3x3 is the same as 4x4, but Skewb is different).
+    def puzzles
+      raise NotImplementedError
+    end
+
+    # Return an algorithm from cancelling this move with `other` and cancelling as much as
+    # possible.
+    # Note that it doesn't cancel rotations with moves even if we theoretically could do this by
+    # using uncanonical wide moves.
+    # Expects prepend_xyz methods to be present. That one can return a cancelled implementation
+    # or nil if nothing can be cancelled.
+    def join_with_cancellation(other, cube_size)
+      raise ArgumentError if (puzzles & other.puzzles).empty?
+
+      maybe_alg = prepend_to(other, cube_size)
+      if maybe_alg
+        Algorithm.new(maybe_alg.moves.select { |m| m.direction.non_zero? })
+      else
+        Algorithm.new([self, other].select { |m| m.direction.non_zero? })
+      end
+    end
+
+    # We handle the annoying inconsistency that u is a slice move for bigger cubes, but a fat
+    # move for 3x3. Furthermore, M slice moves are fat m slice moves for even cubes and normal
+    # m slice moves for odd cubes.
+    def decide_meaning(_cube_size)
+      self
+    end
+
+    # In terms of prepending, inner M slice moves are exactly like other slice moves.
+    def prepend_inner_m_slice_move(other, cube_size)
+      prepend_slice_move(other, cube_size)
+    end
+
+    private
+
+    def move_count_internal(metric, slice_factor, direction_factor)
+      case metric
+      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
+      else raise ArgumentError, "Invalid move metric #{metric.inspect}."
+      end
+    end
+
+    def prepend_to(other, cube_size)
+      this = decide_meaning(cube_size)
+      other = other.decide_meaning(cube_size)
+      method_symbol = "prepend_#{snake_case_class_name(this.class)}".to_sym
+      unless other.respond_to?(method_symbol)
+        raise NotImplementedError, "#{other.class}##{method_symbol} is not implemented"
+      end
+
+      other.method(method_symbol).call(this, cube_size)
+    end
+  end
+end

data/lib/twisty_puzzles/abstract_move_parser.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module TwistyPuzzles
+  
+    # Base class for move parsers.
+    class AbstractMoveParser
+      def regexp
+        raise NotImplementedError
+      end
+
+      def parse_part_key(_name)
+        raise NotImplementedError
+      end
+
+      def parse_move_part(_name, _string)
+        raise NotImplementedError
+      end
+
+      def move_type_creators
+        raise NotImplementedError
+      end
+
+      def parse_named_captures(match)
+        present_named_captures = match.named_captures.reject { |_n, v| v.nil? }
+        present_named_captures.map do |name, string|
+          key = parse_part_key(name).to_sym
+          value = parse_move_part(name, string)
+          [key, value]
+        end.to_h
+      end
+
+      def parse_move(move_string)
+        match = move_string.match(regexp)
+        if !match || !match.pre_match.empty? || !match.post_match.empty?
+          raise ArgumentError("Invalid move #{move_string}.")
+        end
+
+        parsed_parts = parse_named_captures(match)
+        move_type_creators.each do |parser|
+          return parser.create(parsed_parts) if parser.applies_to?(parsed_parts)
+        end
+        raise "No move type creator applies to #{parsed_parts}"
+      end
+    end
+end

data/lib/twisty_puzzles/algorithm.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'twisty_puzzles/abstract_move'
+require 'twisty_puzzles/reversible_applyable'
+require 'twisty_puzzles/cancellation_helper'
+require 'twisty_puzzles/cube_state'
+require 'twisty_puzzles/compiled_cube_algorithm'
+require 'twisty_puzzles/compiled_skewb_algorithm'
+
+module TwistyPuzzles
+  
+    # Represents a sequence of moves that can be applied to puzzle states.
+    class Algorithm
+      include ReversibleApplyable
+      include Comparable
+
+      def initialize(moves)
+        moves.each do |m|
+          raise TypeError, "#{m.inspect} is not a suitable move." unless m.is_a?(AbstractMove)
+        end
+        @moves = moves
+      end
+
+      EMPTY = Algorithm.new([])
+
+      # Creates a one move algorithm.
+      def self.move(move)
+        Algorithm.new([move])
+      end
+
+      attr_reader :moves
+
+      def eql?(other)
+        self.class.equal?(other.class) && @moves == other.moves
+      end
+
+      alias == eql?
+
+      def hash
+        @hash ||= ([self.class] + @moves).hash
+      end
+
+      def length
+        @moves.length
+      end
+
+      def empty?
+        @moves.empty?
+      end
+
+      def to_s
+        @moves.join(' ')
+      end
+
+      def inspect
+        "Algorithm(#{self})"
+      end
+
+      def apply_to(cube_state)
+        case cube_state
+        when SkewbState
+          compiled_for_skewb.apply_to(cube_state)
+        when CubeState
+          compiled_for_cube(cube_state.n).apply_to(cube_state)
+        else
+          raise TypeError, "Unsupported cube state class #{cube_state.class}."
+        end
+      end
+
+      def inverse
+        @inverse ||=
+          begin
+            alg = self.class.new(@moves.reverse.map(&:inverse))
+            alg.inverse = self
+            alg
+          end
+      end
+
+      def +(other)
+        self.class.new(@moves + other.moves)
+      end
+
+      def <=>(other)
+        [length, @moves] <=> [other.length, other.moves]
+      end
+
+      # Returns the cancelled version of the given algorithm.
+      # Note that the cube size is important to know which fat moves cancel
+      def cancelled(cube_size)
+        CancellationHelper.cancel(self, cube_size)
+      end
+
+      # Returns the number of moves that cancel if you concat the algorithm to the right of self.
+      # Note that the cube size is important to know which fat moves cancel
+      def cancellations(other, cube_size, metric = :htm)
+        CubeState.check_cube_size(cube_size)
+        AbstractMove.check_move_metric(metric)
+        cancelled = cancelled(cube_size)
+        other_cancelled = other.cancelled(cube_size)
+        together_cancelled = (self + other).cancelled(cube_size)
+        cancelled.move_count(cube_size, metric) +
+          other_cancelled.move_count(cube_size, metric) -
+          together_cancelled.move_count(cube_size, metric)
+      end
+
+      # Rotates the algorithm, e.g. applying "y" to "R U" becomes "F U".
+      # Applying rotation r to alg a is equivalent to r' a r.
+      # Note that this is not implemented for all moves.
+      def rotate_by(rotation)
+        raise TypeError unless rotation.is_a?(Rotation)
+        return self if rotation.direction.zero?
+
+        self.class.new(@moves.map { |m| m.rotate_by(rotation) })
+      end
+
+      # Mirrors the algorithm and uses the given face as the normal of the mirroring.
+      # E.g. mirroring "R U F" with "R" as the normal face, we get "L U' F'".
+      def mirror(normal_face)
+        raise TypeError unless normal_face.is_a?(Face)
+
+        self.class.new(@moves.map { |m| m.mirror(normal_face) })
+      end
+
+      # Cube size is needed to decide whether 'u' is a slice move (like on bigger cubes) or a
+      # fat move (like on 3x3).
+      def move_count(cube_size, metric = :htm)
+        raise TypeError unless cube_size.is_a?(Integer)
+
+        AbstractMove.check_move_metric(metric)
+        return 0 if empty?
+
+        @moves.map { |m| m.move_count(cube_size, metric) }.reduce(:+)
+      end
+
+      def *(other)
+        raise TypeError unless other.is_a?(Integer)
+        raise ArgumentError if other.negative?
+
+        self.class.new(@moves * other)
+      end
+
+      def compiled_for_skewb
+        @compiled_for_skewb ||= CompiledSkewbAlgorithm.for_moves(@moves)
+      end
+
+      def compiled_for_cube(cube_size)
+        (@compiled_for_cube ||= {})[cube_size] ||=
+          CompiledCubeAlgorithm.for_moves(cube_size, @moves)
+      end
+
+      protected
+
+      attr_writer :inverse
+    end
+end