rubiks_cube 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6c52f18a7cefa561a5ddcf4e3ced978f5da8b921
+  data.tar.gz: d876ec06323fb7574a7c14d585bbe9b5d247dd5d
+SHA512:
+  metadata.gz: 0bfdc210f6c713f895c216b943b9bfd5ec186963a066c88c91a1748b50a77f32c5628b2976d43c97e606c783dd8c9a8d843474a3c6718df29c6a313a2b39f7b5
+  data.tar.gz: 2a673c8aa861243b077c1e026fdcb81488c570949d6008758d2f7f7b47a779aead7b10304edfb502fed4e0f257eefbdb59f89356cbf33e959eb3e3f8b8b825af

data/.gitignore

@@ -0,0 +1,18 @@
+*.swp
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/CONTRIBUTING.md

@@ -0,0 +1,13 @@
+# Contributing
+
+Want to contribute? Awesome! Thank you so much.
+
+## How?
+
+1. [Fork it](https://help.github.com/articles/fork-a-repo)
+2. Create a feature branch (`git checkout -b my-new-feature`)
+3. Commit changes, **with tests** (`git commit -am 'Add some feature'`)
+4. Run the tests (`bundle exec rake`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new [Pull
+   Request](https://help.github.com/articles/using-pull-requests)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rubiks_cube.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Chris Hunt
+
+MIT License
+
+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,16 @@
+# Rubik's Cube
+![](http://www.mikesfreegifs.com/main4/underconstruction/atwork89.gif)
+
+## Description
+
+## Usage
+
+## Installation
+
+## Contributing
+Please see the [Contributing
+Document](https://github.com/chrishunt/rubiks-cube/blob/master/CONTRIBUTING.md)
+
+## License
+Copyright (C) 2013 Chris Hunt, [MIT
+License](https://github.com/chrishunt/rubiks-cube/blob/master/LICENSE.txt)

data/Rakefile

@@ -0,0 +1,18 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'cane/rake_task'
+require 'cane/hashcheck'
+
+desc 'Run all tests'
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = '--color --order random'
+end
+
+desc 'Check code quality'
+Cane::RakeTask.new(:quality) do |task|
+  task.abc_max = 9
+  task.use Cane::HashCheck
+end
+
+task default: :spec
+task default: :quality

data/lib/rubiks_cube/algorithms.rb

@@ -0,0 +1,78 @@
+module RubiksCube
+  module Algorithms
+    def self.reverse(algorithm)
+      algorithm.split.map do |move|
+        case modifier = move[-1]
+        when "'"
+          move[0]
+        when "2"
+          move
+        else
+          "#{move}'"
+        end
+      end.reverse.join ' '
+    end
+
+    module Permutation
+      Edge = "R U R' U' R' F R2 U' R' U' R U R' F'"
+      Corner = "U F R U' R' U' R U R' F' R U R' U' R' F R F' U'"
+
+      module Setup
+        Edge = {
+          0  => "M2 D L2",
+          2  => "M2 D' L2",
+          3  => "",
+          4  => "U' F U",
+          5  => "U' F' U",
+          6  => "U B U'",
+          7  => "U B' U'",
+          8  => "D' L2",
+          9  => "D2 L2",
+          10 => "D L2",
+          11 => "L2"
+        }
+
+        Corner = {
+          1 => "R2 D' R2",
+          2 => "",
+          3 => "B2 D' R2",
+          4 => "D R2",
+          5 => "R2",
+          6 => "D' R2",
+          7 => "D2 R2"
+        }
+      end
+    end
+
+    module Orientation
+      Edge = "M' U M' U M' U2 M U M U M U2"
+      Corner = "R' D R F D F' U' F D' F' R' D' R U"
+
+      module Setup
+        Edge = {
+          1  => "R B",
+          2  => "",
+          3  => "L' B'",
+          4  => "L2 B'",
+          5  => "R2 B",
+          6  => "B",
+          7  => "B'",
+          8  => "D2 B2",
+          9  => "D B2",
+          10 => "B2",
+          11 => "D' B2"
+        }
+
+        Corner = {
+          1 => "",
+          2 => "R'",
+          3 => "B2 R2",
+          4 => "D2 R2",
+          5 => "D R2",
+          6 => "R2",
+          7 => "D' R2"
+        }
+      end
+    end
+  end
+end

data/lib/rubiks_cube/corner_cubie.rb

@@ -0,0 +1,8 @@
+module RubiksCube
+  CornerCubie = Struct.new(:state) do
+    def rotate!
+      u, r, f = state.split ''
+      self.state = [f, u, r].join
+    end
+  end
+end

data/lib/rubiks_cube/cube.rb

@@ -0,0 +1,203 @@
+module RubiksCube
+  # Standard 3x3x3 Rubik's Cube with normal turn operations (l, r, u, d, f, b)
+  class Cube
+    SOLVED_STATE = %w(
+      UF UR UB UL FL FR BR BL DF DR DB DL UFL URF UBR ULB DLF DFR DRB DBL
+    )
+
+    def initialize(state = nil)
+      @state = build_state_from_string(
+        state.to_s.empty? ? SOLVED_STATE.join(' ') : state
+      )
+    end
+
+    def ==(other)
+      state == other.state
+    end
+
+    def state
+      @state.join ' '
+    end
+
+    def edges
+      @state[0..11]
+    end
+
+    def corners
+      @state[12..-1]
+    end
+
+    def solved?
+      state == SOLVED_STATE.join(' ')
+    end
+
+    def edge_permuted?(edge)
+      cubie_permuted? :edges, edge
+    end
+
+    def corner_permuted?(corner)
+      cubie_permuted? :corners, corner
+    end
+
+    def has_correct_edge_permutation?
+      incorrect_edge_permutation_locations.empty?
+    end
+
+    def has_correct_corner_permutation?
+      incorrect_corner_permutation_locations.empty?
+    end
+
+    def has_correct_edge_orientation?
+      incorrect_edge_orientation_locations.empty?
+    end
+
+    def has_correct_corner_orientation?
+      incorrect_corner_orientation_locations.empty?
+    end
+
+    def incorrect_edge_permutation_locations
+      unpermuted_locations_for :edges
+    end
+
+    def incorrect_corner_permutation_locations
+      unpermuted_locations_for :corners
+    end
+
+    def incorrect_edge_orientation_locations
+      unoriented_locations_for :edges
+    end
+
+    def incorrect_corner_orientation_locations
+      unoriented_locations_for :corners
+    end
+
+    def permuted_location_for(cubie)
+      while (location = SOLVED_STATE.index cubie.state) == nil
+        cubie = cubie.rotate
+      end
+
+      location -= 12 if location >= 12
+      location
+    end
+
+    def perform!(algorithm)
+      algorithm.split.each { |move| perform_move! move }
+      algorithm
+    end
+
+    def undo!(algorithm)
+      perform! reverse(algorithm)
+    end
+
+    def r
+      turn [1, 5, 9, 6]
+      turn [13, 17, 18, 14]
+      rotate [13, 13, 14, 17, 18, 18]
+      self
+    end
+
+    def l
+      turn [3, 7, 11, 4]
+      turn [12, 15, 19, 16]
+      rotate [12, 15, 15, 16, 16, 19]
+      self
+    end
+
+    def u
+      turn [0, 1, 2, 3]
+      turn [12, 13, 14, 15]
+      self
+    end
+
+    def d
+      turn [8, 11, 10, 9]
+      turn [16, 19, 18, 17]
+      self
+    end
+
+    def f
+      turn [0, 4, 8, 5]
+      rotate [0, 4, 8, 5]
+      turn [12, 16, 17, 13]
+      rotate [12, 12, 13, 16, 17, 17]
+      self
+    end
+
+    def b
+      turn [2, 6, 10, 7]
+      rotate [2, 6, 10, 7]
+      turn [14, 18, 19, 15]
+      rotate [14, 14, 15, 18, 19, 19]
+      self
+    end
+
+    def m
+      turn [0, 2, 10, 8]
+      rotate [0, 2, 10, 8]
+      self
+    end
+
+    private
+
+    def build_state_from_string(state)
+      state.split.map { |state| RubiksCube::Cubie.new state }
+    end
+
+    def cubie_permuted?(type, cubie)
+      send(type).index(cubie) == permuted_location_for(cubie)
+    end
+
+    def unpermuted_locations_for(type)
+      send(type).each_with_index.map do |cubie, location|
+        location unless location == permuted_location_for(cubie)
+      end.compact
+    end
+
+    def unoriented_locations_for(type)
+      send(type).each_with_index.map do |cubie, location|
+        oriented_state = SOLVED_STATE.fetch(
+          if type == :corners
+            location + 12
+          else
+            location
+          end
+        )
+
+        location unless cubie.state == oriented_state
+      end.compact
+    end
+
+    def turn(sequence)
+      current_cubie = sequence.shift
+      first_cubie = @state[current_cubie]
+
+      sequence.each do |cubie|
+        @state[current_cubie] = @state[cubie]
+        current_cubie = cubie
+      end
+
+      @state[current_cubie] = first_cubie
+    end
+
+    def rotate(cubies)
+      cubies.each { |cubie| @state[cubie].rotate! }
+    end
+
+    def perform_move!(move)
+      operation = "#{move[0].downcase}"
+
+      case modifier = move[-1]
+        when "'"
+          3.times { send operation }
+        when "2"
+          2.times { send operation }
+        else
+          send operation
+      end
+    end
+
+    def reverse(algorithm)
+      RubiksCube::Algorithms.reverse algorithm
+    end
+  end
+end

data/lib/rubiks_cube/cubie.rb

@@ -0,0 +1,29 @@
+module RubiksCube
+  # Generic cubie piece, either edge cubie or corner cubie
+  class Cubie
+    def initialize(state)
+      @cubie = state.size == 2 ? EdgeCubie.new(state) : CornerCubie.new(state)
+    end
+
+    def ==(other)
+      state == other.state
+    end
+
+    def state
+      @cubie.state
+    end
+
+    def rotate!
+      @cubie.rotate!
+      self
+    end
+
+    def rotate
+      Cubie.new(state.dup).rotate!
+    end
+
+    def to_s
+      @cubie.state
+    end
+  end
+end

data/lib/rubiks_cube/edge_cubie.rb

@@ -0,0 +1,7 @@
+module RubiksCube
+  EdgeCubie = Struct.new(:state) do
+    def rotate!
+      state.reverse!
+    end
+  end
+end

data/lib/rubiks_cube/two_cycle_solution.rb

@@ -0,0 +1,120 @@
+module RubiksCube
+  # Very inefficient two-cycle solving algorithm, useful for blindfold
+  class TwoCycleSolution
+    attr_reader :cube
+
+    def initialize(cube)
+      @cube = Cube.new(cube.state)
+    end
+
+    def state
+      cube.state
+    end
+
+    def solved?
+      cube.solved?
+    end
+
+    def solve!
+      @solution ||= begin
+        solution = []
+        solution << solution_for(:permutation)
+        solution << solution_for(:orientation)
+        solution.flatten
+      end
+    end
+
+    def solution
+      solve!
+      @solution
+    end
+
+    def solution_length
+      solution.flatten.join(' ').split.count
+    end
+
+    def pretty
+      solution.each_slice(3).map do |setup, correction, undo|
+        step = []
+        step << "Setup:\t#{setup}" unless setup.empty?
+        step << "Fix:\t#{correction}"
+        step << "Undo:\t#{undo}" unless undo.empty?
+        step.join "\n"
+      end.join("\n\n").strip
+    end
+
+    private
+
+    def solution_for(step)
+      [:edge, :corner].map do |cubie|
+        solve_for cubie, step
+      end
+    end
+
+    def solve_for(cubie, step)
+      solution = []
+      solution << [perform(cubie, step)] until finished_with?(cubie, step)
+      solution
+    end
+
+    def finished_with?(cubie, step)
+      cube.public_send "has_correct_#{cubie}_#{step}?"
+    end
+
+    def perform(cubie, step)
+      algorithms_for(cubie, step).map { |algorithm| cube.perform! algorithm }
+    end
+
+    def next_orientation_location_for(cubie)
+      incorrect_locations_for(cubie, :orientation).tap do |locations|
+        locations.delete(0)
+      end.first
+    end
+
+    def next_permutation_location_for(cubie)
+      buffer_cubie = send("permutation_buffer_#{cubie}")
+
+      if cube.public_send("#{cubie}_permuted?", buffer_cubie)
+        incorrect_locations_for(cubie, :permutation).first
+      else
+        cube.permuted_location_for buffer_cubie
+      end
+    end
+
+    def permutation_buffer_edge
+      cube.edges[1]
+    end
+
+    def permutation_buffer_corner
+      cube.corners[0]
+    end
+
+    def incorrect_locations_for(cubie, step)
+      cube.public_send "incorrect_#{cubie}_#{step}_locations"
+    end
+
+    def algorithms_for(cubie, step)
+      location   = send("next_#{step}_location_for", cubie)
+      setup      = setup_algorithms_for(cubie, step, location)
+      correction = correction_algorithm_for(cubie, step)
+      undo       = RubiksCube::Algorithms.reverse(setup)
+
+      [ setup, correction, undo ]
+    end
+
+    def correction_algorithm_for(cubie, step)
+      load_algorithms step, cubie
+    end
+
+    def setup_algorithms_for(cubie, step, location)
+      load_algorithms(step, 'setup', cubie).fetch(location)
+    end
+
+    def load_algorithms(*classes)
+      Kernel.const_get(
+        "RubiksCube::Algorithms::" <<
+        classes.map(&:capitalize).flatten.join('::')
+      )
+    end
+  end
+end

data/lib/rubiks_cube/version.rb

@@ -0,0 +1,3 @@
+module RubiksCube
+  VERSION = '0.0.1'
+end

data/lib/rubiks_cube.rb

@@ -0,0 +1,7 @@
+require 'rubiks_cube/version'
+require 'rubiks_cube/cube'
+require 'rubiks_cube/cubie'
+require 'rubiks_cube/algorithms'
+require 'rubiks_cube/edge_cubie'
+require 'rubiks_cube/corner_cubie'
+require 'rubiks_cube/two_cycle_solution'

data/rubiks_cube.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rubiks_cube/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rubiks_cube'
+  spec.version       = RubiksCube::VERSION
+  spec.authors       = ['Chris Hunt']
+  spec.email         = ['c@chrishunt.co']
+  spec.description   = %q{Learn how to solve the Rubik's Cube. It's easy!}
+  spec.summary       = %q{Learn how to solve the Rubik's Cube. It's easy!}
+  spec.homepage      = 'https://github.com/chrishunt/rubiks-cube'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'cane-hashcheck'
+end

data/spec/rubiks_cube/algorithms_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe RubiksCube::Algorithms do
+  subject { described_class }
+
+  describe '.reverse' do
+    it 'reverses the algorithm' do
+      expect(subject.reverse "F' B L2 U' R").to eq "R' U L2 B' F"
+    end
+  end
+end

data/spec/rubiks_cube/cube_spec.rb

@@ -0,0 +1,385 @@
+require 'spec_helper'
+
+describe RubiksCube::Cube do
+  subject { described_class.new state }
+
+  let(:state) { nil }
+
+  describe '#initialize' do
+    context 'when a state is provided' do
+      let(:state) { 'some state' }
+
+      it 'is initialized with the state' do
+        expect(subject.state).to eq state
+      end
+    end
+
+    context 'when no state is provided' do
+      let(:state) { nil }
+
+      it 'is initialized with the solved state' do
+        expect(subject.state).to eq RubiksCube::Cube::SOLVED_STATE.join ' '
+      end
+    end
+  end
+
+  describe '==' do
+    it 'returns true when two cubes have the same state' do
+      expect(subject).to eq described_class.new(state)
+    end
+
+    it 'returns false when two cubes do not have the same state' do
+      expect(subject).to_not eq described_class.new(state).d
+    end
+  end
+
+  describe '#edges' do
+    it 'returns all the edges' do
+      expect(subject.edges).to eq(
+        subject.state.split[0..11].map { |cubie| RubiksCube::Cubie.new cubie }
+      )
+    end
+  end
+
+  describe '#corners' do
+    it 'returns all the corners' do
+      expect(subject.corners).to eq(
+        subject.state.split[12..-1].map { |cubie| RubiksCube::Cubie.new cubie }
+      )
+    end
+  end
+
+  describe '#incorrect_edge_permutation_locations' do
+    context 'with unpermuted edges' do
+      let(:state) {
+        'UF UL UB UR FL FR BR BL DF DL DB DR UFL URF UBR ULB DLF DFR DRB DBL'
+      }
+
+      it 'returns the location of all unpermuted edges' do
+        expect(
+          subject.incorrect_edge_permutation_locations
+        ).to eq [1, 3, 9, 11]
+      end
+    end
+
+    context 'with permuted edges' do
+      it 'returns an empty array' do
+        expect(subject.incorrect_edge_permutation_locations).to eq []
+      end
+    end
+  end
+
+  describe '#incorrect_corner_permutation_locations' do
+    context 'with unpermuted corners' do
+      let(:state){
+        'UF UR UB UL FL FR BR BL DF DR DB DL ULB UBR URF UFL DLF DFR DRB DBL'
+      }
+
+      it 'returns the locations of all unpermuted corners' do
+        expect(
+          subject.incorrect_corner_permutation_locations
+        ).to eq [0, 1, 2, 3]
+      end
+    end
+
+    context 'with permuted corners' do
+      it 'returns an empty array' do
+        expect(subject.incorrect_corner_permutation_locations).to eq []
+      end
+    end
+  end
+
+  describe '#incorrect_edge_orientation_locations' do
+    context 'with edges that are not oriented' do
+      let(:state) {
+        'FU UR BU UL FL RF RB LB FD DR DB DL UFL URF UBR ULB DLF DFR DRB DBL'
+      }
+
+      it 'returns the locations of all unoriented edges' do
+        expect(
+          subject.incorrect_edge_orientation_locations
+        ).to eq [0, 2, 5, 6, 7, 8]
+      end
+    end
+
+    context 'with oriented edges' do
+      it 'returns an empty array' do
+        expect(subject.incorrect_edge_orientation_locations).to eq []
+      end
+    end
+  end
+
+  describe '#incorrect_corner_orientation_locations' do
+    context 'with corners that are not oriented' do
+      let(:state) {
+        'UF UR UB UL FL FR BR BL DF DR DB DL FLU FUR UBR ULB DLF DFR DRB DBL'
+      }
+
+      it 'returns the locations of all unoriented corners' do
+        expect(subject.incorrect_corner_orientation_locations).to eq [0, 1]
+      end
+    end
+
+    context 'with oriented corners' do
+      it 'returns an empty array' do
+        expect(subject.incorrect_corner_orientation_locations).to eq []
+      end
+    end
+  end
+
+  describe '#permuted_location_for' do
+    RubiksCube::Cube::SOLVED_STATE.each_with_index do |cubie, location|
+      it "returns the correct location for the '#{cubie}' cubie" do
+        # Both corner and edge index begins at zero
+        location -= 12 if location >= 12
+
+        cubie = RubiksCube::Cubie.new cubie
+
+        expect(subject.permuted_location_for cubie).to eq location
+      end
+    end
+
+    context 'when the cubie has been rotated' do
+      let(:cubie) { subject.corners.first }
+
+      before { cubie.rotate! }
+
+      it 'still finds the correct location' do
+        expect(subject.permuted_location_for cubie).to eq 0
+      end
+
+      it 'does not rotate the cubie' do
+        original_state = cubie.state
+
+        subject.permuted_location_for cubie
+
+        expect(cubie.state).to eq original_state
+      end
+    end
+  end
+
+  describe '#solved?' do
+    it 'returns true when cube is solved' do
+      expect(subject).to be_solved
+    end
+
+    it 'returns false when cube is not solved' do
+      subject.l
+      expect(subject).to_not be_solved
+    end
+  end
+
+  describe '#edge_permuted?' do
+    it 'returns true when the cubie is permuted' do
+      subject.u
+
+      permuted_edge = subject.edges[4]
+      unpermuted_edge = subject.edges[0]
+
+      expect(subject.edge_permuted? unpermuted_edge).to be_false
+      expect(subject.edge_permuted? permuted_edge).to be_true
+    end
+  end
+
+  describe '#corner_permuted?' do
+    it 'returns true when the cubie is permuted' do
+      subject.f
+
+      permuted_corner = subject.corners[2]
+      unpermuted_corner = subject.corners[1]
+
+      expect(subject.corner_permuted? unpermuted_corner).to be_false
+      expect(subject.corner_permuted? permuted_corner).to be_true
+    end
+  end
+
+  describe '#has_correct_edge_permutation?' do
+    context 'when the edges are permuted, but corners are not' do
+      let(:state) {
+        'UF UR UB UL FL FR BR BL DF DR DB DL ULB UBR URF UFL DBL DRB DFR DLF'
+      }
+
+      it 'returns true' do
+        expect(subject).to have_correct_edge_permutation
+      end
+    end
+
+    context 'when the edges are not permuted, but corners are' do
+      let(:state) {
+        'UL UF UB UR FL FR BR BL DF DR DB DL UFL URF UBR ULB DLF DFR DRB DBL'
+      }
+
+      it 'returns false' do
+        expect(subject).to_not have_correct_edge_permutation
+      end
+    end
+  end
+
+  describe '#has_correct_corner_permutation?' do
+    context 'when the corners are permuted, but the edges are not' do
+      let(:state) {
+        'UL UF UB UR FL FR BR BL DF DR DB DL UFL URF UBR ULB DLF DFR DRB DBL'
+      }
+
+      it 'returns true' do
+        expect(subject).to have_correct_corner_permutation
+      end
+    end
+
+    context 'when the corners are not permuted, but the edges are permuted' do
+      let(:state) {
+        'UF UR UB UL FL FR BR BL DF DR DB DL ULB UBR URF UFL DBL DRB DFR DLF'
+      }
+
+      it 'returns false' do
+        expect(subject).to_not have_correct_corner_permutation
+      end
+    end
+  end
+
+  describe '#has_correct_edge_orientation?' do
+    context 'when the edges are oriented, but the corners are not' do
+      let(:state) {
+        'UF UR UB UL FL FR BR BL DF DR DB DL LUF RFU UBR ULB DLF DFR DRB DBL'
+      }
+
+      it 'returns true' do
+        expect(subject).to have_correct_edge_orientation
+      end
+    end
+
+    context 'when the edges are not oriented, but the corners are' do
+      let(:state) {
+        'FU UR BU UL FL FR BR BL DF DR DB DL UFL URF UBR ULB DLF DFR DRB DBL'
+      }
+
+      it 'returns false' do
+        expect(subject).to_not have_correct_edge_orientation
+      end
+    end
+  end
+
+  describe '#has_correct_corner_orientation?' do
+    context 'when the corners are oriented, but the edges are not' do
+      let(:state) {
+        'FU UR BU UL FL FR BR BL DF DR DB DL UFL URF UBR ULB DLF DFR DRB DBL'
+      }
+
+      it 'returns true' do
+        expect(subject).to have_correct_corner_orientation
+      end
+    end
+
+    context 'when the corners are not oriented, but the edges are' do
+      let(:state) {
+        'UF UR UB UL FL FR BR BL DF DR DB DL LUF RFU UBR ULB DLF DFR DRB DBL'
+      }
+
+      it 'returns false' do
+        expect(subject).to_not have_correct_corner_orientation
+      end
+    end
+  end
+
+  describe '#perform!' do
+    it 'performs the algorithm on the cube' do
+      subject.perform! "U2 D' L R F B"
+
+      expect(subject.state).to eq(
+        described_class.new.u.u.d.d.d.l.r.f.b.state
+      )
+    end
+
+    it 'returns the algorithm that was performed' do
+      algorithm = "F2 U' L"
+
+      expect(subject.perform! algorithm).to eq algorithm
+    end
+  end
+
+  describe '#undo!' do
+    it 'performs the algorithm in reverse on the cube' do
+      subject.f.f.f.b.l.l.u.u.u.r
+
+      subject.undo! "F' B L2 U' R"
+
+      expect(subject).to be_solved
+    end
+  end
+
+  describe 'face turns' do
+    shared_examples_for 'a face turn' do
+      it "rotates the face 90 degrees clockwise" do
+        subject.public_send direction
+        expect(subject.state).to eq expected_state
+      end
+
+      it 'is chainable' do
+        expect(subject.public_send direction).to eq subject
+      end
+    end
+
+    describe '#r' do
+      let(:direction) { 'r' }
+      let(:expected_state) {
+        'UF FR UB UL FL DR UR BL DF BR DB DL UFL FRD FUR ULB DLF BDR BRU DBL'
+      }
+
+      it_should_behave_like 'a face turn'
+    end
+
+    describe '#l' do
+      let(:direction) { 'l' }
+      let(:expected_state) {
+        'UF UR UB BL UL FR BR DL DF DR DB FL BUL URF UBR BLD FLU DFR DRB FDL'
+      }
+
+      it_should_behave_like 'a face turn'
+    end
+
+    describe '#u' do
+      let(:direction) { 'u' }
+      let(:expected_state) {
+        'UR UB UL UF FL FR BR BL DF DR DB DL URF UBR ULB UFL DLF DFR DRB DBL'
+      }
+
+      it_should_behave_like 'a face turn'
+    end
+
+    describe '#d' do
+      let(:direction) { 'd' }
+      let(:expected_state) {
+        'UF UR UB UL FL FR BR BL DL DF DR DB UFL URF UBR ULB DBL DLF DFR DRB'
+      }
+
+      it_should_behave_like 'a face turn'
+    end
+
+    describe '#f' do
+      let(:direction) { 'f' }
+      let(:expected_state) {
+        'LF UR UB UL FD FU BR BL RF DR DB DL LFD LUF UBR ULB RDF RFU DRB DBL'
+      }
+
+      it_should_behave_like 'a face turn'
+    end
+
+    describe '#b' do
+      let(:direction) { 'b' }
+      let(:expected_state) {
+        'UF UR RB UL FL FR BD BU DF DR LB DL UFL URF RBD RUB DLF DFR LDB LBU'
+      }
+
+      it_should_behave_like 'a face turn'
+    end
+
+    describe '#m' do
+      let(:direction) { 'm' }
+      let(:expected_state) {
+        'BU UR BD UL FL FR BR BL FU DR FD DL UFL URF UBR ULB DLF DFR DRB DBL'
+      }
+
+      it_should_behave_like 'a face turn'
+    end
+  end
+end

data/spec/rubiks_cube/cubie_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe RubiksCube::Cubie do
+  subject { described_class.new state }
+
+  let(:state) { 'UF' }
+
+  it 'is initialized with a state' do
+    expect(subject.state).to eq state
+  end
+
+  describe '==' do
+    context 'when the state equals the state of the other' do
+      it 'returns true' do
+        expect(subject == described_class.new(state)).to be_true
+      end
+    end
+
+    context 'when the state does not equal the state of the other' do
+      it 'returns true' do
+        expect(subject == described_class.new('UB')).to be_false
+      end
+    end
+  end
+
+  describe '#to_s' do
+    it 'converts the cubie to a string' do
+      expect(subject.to_s).to eq state
+    end
+  end
+
+  describe '#rotate!' do
+    context 'with an edge piece' do
+      let(:state) { 'UF' }
+
+      it 'flips the cubie' do
+        expect(subject.rotate!.state).to eq 'FU'
+        expect(subject.rotate!.state).to eq state
+      end
+    end
+
+    context 'with a corner piece' do
+      let(:state) { 'URF' }
+
+      it 'rotates the cubie once couter clockwise' do
+        expect(subject.rotate!.state).to eq 'FUR'
+        expect(subject.rotate!.state).to eq 'RFU'
+        expect(subject.rotate!.state).to eq state
+      end
+    end
+  end
+
+  describe '#rotate' do
+    it "returns a new cubie that's been rotated" do
+      expect(subject.rotate).to eq described_class.new(state).rotate!
+    end
+
+    it 'does not modify the cubie' do
+      original_state = subject.state.dup
+
+      subject.rotate
+
+      expect(subject.state).to eq original_state
+    end
+  end
+
+end

data/spec/rubiks_cube/two_cycle_solution_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe RubiksCube::TwoCycleSolution do
+  subject { described_class.new cube }
+
+  let(:cube)  { RubiksCube::Cube.new state }
+  let(:state) { nil }
+
+  describe '#solve!' do
+    shared_examples_for 'a cube that can be solved' do
+      it 'solves the cube' do
+        subject.solve!
+        expect(subject).to be_solved
+      end
+    end
+
+    it 'does not modify the original cube state' do
+      original_cube_state = cube.l.state
+
+      subject.solve!
+
+      expect(cube.state).to eq original_cube_state
+    end
+
+    context 'when edges need to be swapped' do
+      let(:state) {
+        'UF UL UB UR FL FR BR BL DF DR DB DL UFL UBR URF ULB DLF DFR DRB DBL'
+      }
+
+      it_should_behave_like 'a cube that can be solved'
+    end
+
+    context 'when corners need to be swapped' do
+      let(:state) {
+        'UL UR UB UF FL FR BR BL DF DR DB DL UBR URF UFL ULB DLF DFR DRB DBL'
+      }
+
+      it_should_behave_like 'a cube that can be solved'
+    end
+
+    context 'when two edges have incorrect orientation' do
+      before { cube.perform! RubiksCube::Algorithms::Orientation::Edge }
+
+      it_should_behave_like 'a cube that can be solved'
+    end
+
+    context 'when two corners have incorrect orientation' do
+      before { cube.perform! RubiksCube::Algorithms::Orientation::Corner }
+
+      it_should_behave_like 'a cube that can be solved'
+    end
+
+    [
+      "U2 L' F2 U' B D' R' F2 U F' R L2 F2 L' B L R2 B' D R L' U D' R2 F'",
+      "L U2 R' B2 U D R' U R' B2 L F R2 L' B' R' U2 L2 R2 U F' L' U' L U'",
+      "F' U2 D2 F2 R' D2 B L2 F L2 D2 F U2 F B L U' D' R' F D F' L2 F' B2",
+      "R2 U' D2 B L2 U' R D2 L2 U2 F2 D' B' L B' D L' B2 L' F' L' B2 F2 U' L2",
+      "L2 R D' U2 R L' B2 U' L2 D2 B2 D' R2 L' B' U2 B R2 F2 R' D' F2 D L U",
+    ].each do |scramble|
+      context "with scramble (#{scramble})" do
+        before { cube.perform! scramble }
+
+        it_should_behave_like 'a cube that can be solved'
+      end
+    end
+
+    describe '#solution' do
+      before do
+        cube.perform!([
+          RubiksCube::Algorithms::Permutation::Edge,
+          RubiksCube::Algorithms::Permutation::Corner,
+          RubiksCube::Algorithms::Orientation::Edge,
+        ].join ' ')
+      end
+
+      context 'when the cube has not been solved' do
+        it 'first solves the cube' do
+          subject.should_receive(:solve!)
+          subject.solution
+        end
+      end
+
+      context 'when the cube has been solved' do
+        before { subject.solve! }
+
+        it 'returns the setup, algorithm, and undo moves' do
+          expect(subject.solution).to eq([
+            "", RubiksCube::Algorithms::Permutation::Edge, "",
+            "M2 D L2", RubiksCube::Algorithms::Permutation::Edge, "L2 D' M2",
+            "R2 D' R2", RubiksCube::Algorithms::Permutation::Corner, "R2 D R2",
+            "", RubiksCube::Algorithms::Permutation::Corner, "",
+            "R B", RubiksCube::Algorithms::Orientation::Edge, "B' R'",
+            "", RubiksCube::Algorithms::Orientation::Edge, ""
+          ])
+        end
+      end
+    end
+
+    describe '#solution_length' do
+      it 'returns the length of the solution' do
+        cube.l.r
+        expect(subject.solution_length).to eq 634
+      end
+
+      it 'returns zero when cube already solved' do
+        expect(subject.solution_length).to be_zero
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'rubiks_cube'

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: rubiks_cube
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Chris Hunt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cane-hashcheck
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Learn how to solve the Rubik's Cube. It's easy!
+email:
+- c@chrishunt.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rubiks_cube.rb
+- lib/rubiks_cube/algorithms.rb
+- lib/rubiks_cube/corner_cubie.rb
+- lib/rubiks_cube/cube.rb
+- lib/rubiks_cube/cubie.rb
+- lib/rubiks_cube/edge_cubie.rb
+- lib/rubiks_cube/two_cycle_solution.rb
+- lib/rubiks_cube/version.rb
+- rubiks_cube.gemspec
+- spec/rubiks_cube/algorithms_spec.rb
+- spec/rubiks_cube/cube_spec.rb
+- spec/rubiks_cube/cubie_spec.rb
+- spec/rubiks_cube/two_cycle_solution_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/chrishunt/rubiks-cube
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Learn how to solve the Rubik's Cube. It's easy!
+test_files:
+- spec/rubiks_cube/algorithms_spec.rb
+- spec/rubiks_cube/cube_spec.rb
+- spec/rubiks_cube/cubie_spec.rb
+- spec/rubiks_cube/two_cycle_solution_spec.rb
+- spec/spec_helper.rb