sudoku-jedi 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 74911c606d986649ad04415a8c460349c8cb61dd
+  data.tar.gz: ccd085050a3bfab521a84baaf8c453d1125c2c75
+SHA512:
+  metadata.gz: a43339c43965b19bb3bfd5cbd7a1ee6c4de4f16a419cdff78019c8240d86928a4529e92cfd3134eb9dc0f9fd1b1f8adfd6350a3c161bc2b2e319d3d45b6fe166
+  data.tar.gz: 395aad6b71cb3d67647557b5258c3e3b4864ba30b9f2b3fdfc263d1b01ea203a5bee273a96544f1b9201c0c5310a7ac7e79e9876c543c42f132b46a44480200b

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,14 @@
+lannguage: ruby
+cache: bundler
+
+rvm:
+  - 2.2.0
+
+script: 'bundle exec rake'
+
+notifications:
+  email:
+    recipients:
+      - ajn123@vt.edu 
+  on_failure: change
+  on_success: never

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,77 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec feature)
+
+## Uncomment to clear the screen before every task
+# clearing :on
+
+## Guard internally checks for changes in the Guardfile and exits.
+## If you want Guard to automatically start up again, run guard in a
+## shell loop, e.g.:
+##
+##  $ while bundle exec guard; do echo "Restarting Guard..."; done
+##
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), the you will want to move the Guardfile
+## to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w(erb haml slim))
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.("routing/#{m[1]}_routing"),
+      rspec.spec.("controllers/#{m[1]}_controller"),
+      rspec.spec.("acceptance/#{m[1]}")
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.("features/#{m[1]}") }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 ajn123
+
+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,53 @@
+# Sudoku Jedi
+[![Build Status](https://travis-ci.org/RubyQuarry/sudoku_solver.svg?branch=master)](https://travis-ci.org/RubyQuarry/sudoku_solver)
+[![Coverage Status](https://coveralls.io/repos/RubyQuarry/sudoku_solver/badge.png)](https://coveralls.io/r/RubyQuarry/sudoku_solver)
+[![Gem Version](https://badge.fury.io/rb/sudoku-jedi.svg)](http://badge.fury.io/rb/sudoku-jedi)
+
+Currently solves easy to moderate sudoku puzzles in a flash!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sudoku-jedi'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sudoku_solver
+
+## Usage
+
+Sudoku-Jedi can solve sodokus for you.  All you have to do is put a sudoku in a text with zeros marked as the 
+empty cells for example: a.txt
+```
+043080250
+600000000
+000001094
+900004070
+000608000
+010200003
+820500000
+000000005
+034090710
+```
+
+Then calling
+```
+sudoku-jedi solve a.txt
+```
+will result in your printed answer in the terminal.
+
+
+## Contributing
+
+1. Fork it ( https://github.com/RubyQuarry/sudoku_solver/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+  # Run with `rake spec`
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = ['--color']
+end
+ 
+task :default => :spec

data/bin/sudoku-jedi

@@ -0,0 +1,2 @@
+require 'sudoku_solver/cli'
+CLI.start

data/lib/sudoku_solver/box.rb

@@ -0,0 +1,16 @@
+require_relative 'container'
+
+class Box < Container 
+  attr_accessor :box, :position
+
+  def initialize(arr, y=0, x=0)
+    super(arr)
+    Struct.new("Coordinate", :x, :y) if !Struct::const_defined? "Coordinate"
+    @position = Struct::Coordinate.new(x, y)
+  end
+    
+  def blank_spaces
+    [(position.y / 3) * 3 + (position.x / 3), position.y, position.x]
+  end
+
+end

data/lib/sudoku_solver/cell.rb

@@ -0,0 +1,6 @@
+class Cell
+  attr_accessor :num
+  def initialize(num)
+    @num = num
+  end
+end

data/lib/sudoku_solver/cli.rb

@@ -0,0 +1,14 @@
+require 'thor'
+require_relative 'grid'
+class CLI < Thor
+
+  desc "solve [FILE NAME]", "Solves a sudoku puzzle from a text file"
+  def solve(file_name)
+  	file = File.open(file_name, "rb")
+  	contents = file.read.gsub("\n", "")
+  	contents.gsub!(" ","")
+    grid = Grid.new(contents.scan(/\d{9}/))
+    grid.solve
+    grid.print_values_formatted
+  end
+end

data/lib/sudoku_solver/column.rb

@@ -0,0 +1,6 @@
+require_relative 'container'
+class Column < Container 
+
+
+
+end

data/lib/sudoku_solver/container.rb

@@ -0,0 +1,35 @@
+class Container
+  
+  attr_accessor :arr, :remaining_blocks  
+  def initialize(arr)
+    @arr = arr
+  end
+  # Find the missing elements in the section
+  def difference 
+    complete 
+    remaining 
+  end
+
+  def remaining
+    Array(1..9) - arr
+  end
+
+  def arr
+    @arr.map!(&:to_i)
+  end
+
+  def contain?(num)
+    complete 
+    arr.include? num
+  end
+
+  def pencil_in
+  end
+
+
+  def complete 
+    if remaining.count == 1
+      arr.map { |elem| elem == 0 ? remaining.first : elem }
+    end
+  end
+end

data/lib/sudoku_solver/grid.rb

@@ -0,0 +1,250 @@
+require_relative 'box'
+require_relative 'point'
+require 'set'
+
+class Grid
+  attr_accessor  :remaining_nums, :points
+  def initialize(txt_file)
+    @points = []
+    txt_file.each_with_index do |text, row|
+      text.split("").map(&:to_i).each_with_index do |num, col|
+        @points << Point.new(row, col, num)
+      end
+    end
+    
+    @points.select { |po| po.value == 0 }.each do |poi|
+      poi.nums = Array(1..9) - (get_box(poi.box) + get_row(poi.y) + get_column(poi.x))
+    end
+  end
+
+  def print_values_formatted
+    puts "SOLUTION"
+    @points.each_slice(9) do |s|
+      puts s.map{ |p| p.value}.join
+    end
+  end
+
+  def print_values
+    a = @points.map { |p| p.value}.join
+    puts a 
+    a
+  end
+
+  def get_box(num)
+    @points.select { |point| point.box == num }.map { |b| b.value }
+  end
+
+  def get_row(num)
+    @points.select { |point| point.y == num }.map { |b| b.value }
+  end
+
+  def get_column(num)
+    @points.select { |point| point.x == num }.map { |b| b.value }
+  end
+
+  def fill_row(num)
+    @points.select { |point| point.x == num  }
+  end
+
+  def find_diff(point)
+    point.nums = point.nums - (get_box(point.box) + get_row(point.y) + get_column(point.x))
+  end 
+
+  def flat_points
+    @points.select { |p| p.value == 0 }
+  end
+
+  def get_values(arr)
+    arr.map { |b| b.value }
+  end
+
+  def update_points 
+    @points.select { |po| po.value == 0 }.each do |poi|
+      find_diff(poi)
+    end
+    (0..8).each do |num|
+      [:box, :x, :y].each do |fields|
+        yield @points.select { |p| p.send(fields) == num }
+      end
+    end
+  end 
+
+  def fill_in
+    remaining_points.each do |p|
+      find_diff(p)
+    end
+  end
+
+
+  def remaining_points
+    @points.select { |p| p.value == 0 }
+  end
+
+  def components
+    [:x, :y, :box]
+  end
+
+  def pinned_points
+    remaining_points.each do |point|
+      components.each do |symbol|
+        point.nums.each do |num|
+          if @points.select { |p| p.include?(num) && p.send(symbol) == point.send(symbol) && p != point }.count == 0
+            point.value = num
+          end
+        end
+      end
+    end 
+  end
+
+  def solve
+    while !is_solved?
+      all_naked_pairs
+      hidden_pairs
+      pointing_pairs
+      box_line_reduction
+      x_wing
+    end
+  end
+
+  def all_naked_pairs
+    fill_in
+    pinned_points
+    naked_pairs
+  end
+
+  def naked_pairs
+    remaining_points.each do |point|
+      next if point.nums.count <= 1
+      components.each do |symbol|
+        possible = remaining_points.select { |p| p.subset?(point) && p != point && p.send(symbol) == point.send(symbol) && p.nums.count >= 2 }
+        possible << point
+        if possible.count == point.nums.count
+          compare_points(possible).each do |type|
+            found = remaining_points.select { |p| p.send(type) == point.send(type) && (!possible.include?(p))  }
+            found.each do |f|
+              f.nums = (f.nums - point.nums)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def pointing_pairs
+    all_naked_pairs
+    remaining_points.each do |point|
+      (1..9).each do |num|
+        [:x, :y].each do |symbol|
+          possible = @points.select { |p| p.send(symbol) == point.send(symbol) && p.box == point.box && p.include?(num) }
+          if possible.count >= 2
+            if @points.select { |p| p.box == point.box && (!possible.include?(p)) && p.include?(num) }.count == 0
+              remove = remaining_points.select { |p| p.box != point.box && p.send(symbol) == point.send(symbol) && p.include?(num) }
+              remove.each do |r|
+                r.nums = (r.nums - [num])
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def box_line_reduction
+    pointing_pairs
+    remaining_points.each do |point|
+      (1..9).each do |num|
+        [:x, :y].each do |symbol|
+          possible = remaining_points.select { |p| p.send(symbol) == point.send(symbol) && p.box == point.box && p.include?(num) }
+          if possible.count >= 2
+            if @points.select { |p| p.send(symbol) == point.send(symbol) && (!possible.include?(p)) && p.include?(num) }.count == 0
+              remove = remaining_points.select { |p| p.box == point.box && p.include?(num) && (!possible.include?(p)) }
+              remove.each do |r|
+                r.nums = (r.nums - [num])
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def is_solved?
+    @points.select{ |p| p.value == 0 }.count == 0
+  end
+
+  def print_values_formatted
+    puts "GRID"
+    @points.each_slice(9) do |s|
+      puts s.map{ |p| p.value}.join
+    end
+  end
+
+
+  def compare_points(arr)
+    a = []
+    a << :x if arr.all? { |w| w.x == arr.first.x }
+    a << :y if arr.all? { |s| s.y == arr.first.y }
+    a << :box if arr.all? { |t| t.box == arr.first.box }
+    a
+  end
+
+
+  def hidden_pairs
+    all_naked_pairs
+#   @points.select { |p| p.x == 6  &&  p.y == 4  }.first.nums =  @points.select { |p| p.x == 6  &&  p.y == 4  }.first.nums - [1,5]
+#   @points.select { |p| p.x == 6  &&  p.y == 6  }.first.nums =  @points.select { |p| p.x == 6  &&  p.y == 6  }.first.nums - [3,6]
+    
+    remaining_points.each do |point|
+      next if point.nums.count <= 1
+      point.nums.combination(2).each do |arr|
+        components.each do |symbol|
+          remove = @points.select { |p| p.send(symbol) == point.send(symbol) && arr.to_set.subset?(p.nums.to_set) && p.nums.count >= 2}
+          if remove.count == 2 && @points.select { |p| p.send(symbol) == point.send(symbol) && ( arr.include?(p.value)) }.count == 0
+            #remove.each { |r| r.nums = arr }
+            return
+          end
+        end 
+      end
+    end
+  end
+
+  def box_count(box, num)
+    @points.select { |p| p.box == box && p.nums.to_set.subset?(num.to_set) }.count 
+  end
+
+  def x_wing
+    box_line_reduction
+    remaining_points.each do |point|
+      point.nums.each do |num|
+        [:x, :y].each do |symbol|
+          arr = @points.select{ |p| p.nums.include?(num) && p.send(flip(symbol)) == point.send(flip(symbol)) && p.value == 0  }
+          if arr.count == 2 && @points.select { |p| p.value == num && p.send(flip(symbol)) == point.send(flip(symbol)) }.count == 0
+            last = @points.select { |p| p.nums.include?(num) && arr.map{ |a| a.send(symbol) }.include?(p.send(symbol)) && (!arr.include?(p)) && p.value == 0 && check_row(p.y,p,num,symbol) }
+            if last.all? { |x| x.send(flip(symbol)) == last.first.send(flip(symbol)) } && last.count == 2 && @points.select { |p| p.value == num && p.send(flip(symbol)) == last.first.send(flip(symbol)) }.count == 0
+              final = arr + last 
+              places = final.map { |m| m.send(symbol) }.uniq
+              remaining_points.select { |p| places.include?(p.send(symbol)) && (!final.include?(p)) }.each do |poi|
+                poi.nums = poi.nums - [num]
+              end
+            end
+          end
+        end
+      end 
+    end
+    
+  end
+
+  def check_row(row, point, num, symbol)
+    a = @points.select { |p| p.send(flip(symbol)) == row && p != point  }.map { |x| x.nums }.flatten
+    a.count(num) <= 1
+  end
+
+  def flip(n)
+    if n == :y
+      :x
+    else 
+      :y
+    end
+  end
+
+end

data/lib/sudoku_solver/point.rb

@@ -0,0 +1,71 @@
+require_relative 'container'
+require 'set'
+
+class Point
+  attr_accessor :box, :position, :nums, :value 
+
+  def initialize(y=0, x=0, value = 0)
+    @value = value
+    Struct.new("Coordinate", :x, :y) if !Struct::const_defined? "Coordinate"
+    @position = Struct::Coordinate.new(x, y)
+    @nums = []
+    @box = (position.y / 3) * 3 + (position.x / 3) 
+  end
+
+  def nums
+    @nums.sort
+  end
+
+
+  def share(point)
+    a = []
+    a << :box if @box == point.box
+    a << :x if x == point.x
+    a << :y if y == point.y
+    return a
+  end
+
+  def value=(val)
+    if @value == 0
+      @value = val
+      if @value != 0 
+        @nums = [val]
+      end
+    end
+  end
+
+  def nums=(n)
+    if @value == 0
+      @nums = n
+      if @nums.count == 1
+        @value = @nums.first
+        @nums = [@value]
+      end
+    end
+  end
+
+
+  def include?(num)
+    nums.include?(num) || (num == value)
+  end
+
+  def subset?(point)
+    nums.to_set.subset?(point.nums.to_set)
+  end
+
+
+  def x
+    @position.x
+  end
+
+  def y
+    @position.y
+  end
+    
+  def blank_spaces
+    [(position.y / 3) * 3 + (position.x / 3), position.y, position.x]
+  end
+
+
+end
+

data/lib/sudoku_solver/row.rb

@@ -0,0 +1,4 @@
+require_relative 'container'
+class Row < Container
+  
+end

data/lib/sudoku_solver/version.rb

@@ -0,0 +1,3 @@
+module SudokuSolver
+  VERSION = "0.0.4"
+end

data/lib/sudoku_solver.rb

@@ -0,0 +1,10 @@
+require "sudoku_solver/version"
+require "sudoku_solver/cell"
+require "sudoku_solver/box"
+require 'sudoku_solver/row'
+require 'sudoku_solver/column'
+require 'sudoku_solver/grid'
+require 'sudoku_solver/cli'
+module SudokuSolver
+  # Your code goes here...
+end

data/spec/box_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+describe Box do 
+  let(:box) { Box.new([1,2,4,5,6,7,8,9], 0, 5)}
+  context "Coordinates" do 
+    it "is correct" do 
+      expect(box.blank_spaces).to eql([1, 0, 5])
+      @let_box = Box.new([], 8, 8)
+      expect(@let_box.blank_spaces).to eql([8, 8, 8])
+    end
+  end
+  context "#differance" do
+    it "shows the incorrect differance" do
+      expect(box.difference).to_not eql(Array(5..9))
+    end
+    it "show the correct differance" do 
+      expect(box.difference).to eql([3])
+    end
+  end 
+  context "#complete" do 
+    it "completes the cell" do 
+      @in_box = Box.new([1,0,3,4,5,6,7,8,9])
+      expect(@in_box.complete).to eql(Array(1..9))
+    end
+  end
+end

data/spec/cell_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+describe Cell do
+  let(:cell) { Cell.new(234) }
+  it "#num" do
+    expect(cell.num).to eql(234)
+  end
+  
+end

data/spec/grid_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Grid do
+  let(:grid) { Grid.new(%w{050400716
+                           409061200 
+                           106205400 
+                           007046035 
+                           680390007 
+                           940050680
+                           091003024
+                           060904501 
+                           704510060})}
+
+  context "point conversion" do 
+    
+    it "solves with points" do
+      @new_grid = Grid.new(%w{050030090
+                              200000007
+                              400507008
+                              345601879
+                              791000265
+                              800000003
+                              502403906
+                              683050741
+                              910070032})
+      @new_grid.solve
+      expect(@new_grid.is_solved?).to eql(true)
+    #  puts @new_grid.points[9*9 - 3].nums
+    end
+    it "solves a triplet" do
+      @sec_grid = Grid.new(%w{070408029
+                              002000004
+                              854020007
+                              008374200
+                              020000000
+                              003261700
+                              000093612
+                              200000403
+                              130642070})
+      @sec_grid.solve
+      expect(@sec_grid.print_values).to eql("671438529392715864854926137518374296726859341943261785487593612269187453135642978")
+    end
+    
+     it "solves a hard puzzle" do
+       @hard_grid = Grid.new(%w{300200000
+                                000107000
+                                706030500
+                                070009080
+                                900020004
+                                010800050
+                                009040301
+                                000702000
+                                000008006})
+       @hard_grid.solve
+       expect(@hard_grid.print_values).to eql("351286497492157638786934512275469183938521764614873259829645371163792845547318926")
+    end
+    it "solves x-wing puzzle" do 
+      @x_grid = Grid.new(%w{043080250
+                            600000000
+                            000001094
+                            900004070
+                            000608000
+                            010200003
+                            820500000
+                            000000005
+                            034090710})
+      puts "hard grid"
+       @x_grid.solve
+       expect(@x_grid.print_values).to eql("143986257679425381285731694962354178357618942418279563821567439796143825534892716")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,98 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'sudoku_solver'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/sudoku_solver.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sudoku_solver/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sudoku-jedi"
+  spec.version       = SudokuSolver::VERSION
+  spec.authors       = ["ajn123"]
+  spec.email         = ["ajn123@vt.edu"]
+  spec.summary       = %q{Solves a sudoku puzzle}
+  spec.description   = %q{Solves easy to moderate soduku puzzles efficiently}
+  spec.homepage      = "https://github.com/RubyQuarry/sudoku-jedi"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec-nc"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-remote"
+  spec.add_development_dependency "pry-nav"
+  spec.add_development_dependency "coveralls"
+  spec.add_dependency "thor"
+end
+

metadata

@@ -0,0 +1,228 @@
+--- !ruby/object:Gem::Specification
+name: sudoku-jedi
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- ajn123
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.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: rspec-nc
+  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: guard
+  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: guard-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: pry
+  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: pry-remote
+  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: pry-nav
+  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: coveralls
+  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: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Solves easy to moderate soduku puzzles efficiently
+email:
+- ajn123@vt.edu
+executables:
+- sudoku-jedi
+extensions: []
+extra_rdoc_files: []
+files:
+- ".coveralls.yml"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/sudoku-jedi
+- lib/sudoku_solver.rb
+- lib/sudoku_solver/box.rb
+- lib/sudoku_solver/cell.rb
+- lib/sudoku_solver/cli.rb
+- lib/sudoku_solver/column.rb
+- lib/sudoku_solver/container.rb
+- lib/sudoku_solver/grid.rb
+- lib/sudoku_solver/point.rb
+- lib/sudoku_solver/row.rb
+- lib/sudoku_solver/version.rb
+- spec/box_spec.rb
+- spec/cell_spec.rb
+- spec/grid_spec.rb
+- spec/spec_helper.rb
+- sudoku_solver.gemspec
+homepage: https://github.com/RubyQuarry/sudoku-jedi
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Solves a sudoku puzzle
+test_files:
+- spec/box_spec.rb
+- spec/cell_spec.rb
+- spec/grid_spec.rb
+- spec/spec_helper.rb