sudoku_bad 0.0.2

data/lib/sudoku/model/grid.rb

@@ -0,0 +1,98 @@
+require 'sudoku/model/coordinate'
+
+module Sudoku
+  # Represents the Sudoku Grid model.
+  class Grid
+    attr_reader :cells
+
+    # Will initialize this grid by given hash of cells. If no
+    # cells are given, the grid will have empty values and
+    # default cells.
+    def initialize(cells = {})
+      @cells = cells
+      GridFactory.new.generate_all_coordinates.each do |x|
+        add_cell(generate_default_cell(x))
+      end if cells.empty?
+    end
+
+    # Will return true, if all filled values are other than 0.
+    def filled?
+      !cells.values.collect(&:value).include?(0)
+    end
+
+    # Will return true, if rules of Sudoku are violated in this
+    # grid. Ignores values 0.
+    def rules_violated?
+      Solver.new(self).rules_violated?
+    end
+
+    # Will return cell at random position from this grid.
+    def random_cell
+      get_cell(CellCoordinates.random)
+    end
+
+    # Will return particular cell based on given coordinates. If
+    # there is not cell on given coordinates, default cell will
+    # be created (not filled, editable).
+    # * +coordinates+ cell coordinates.
+    def get_cell(coordinates)
+      cells[coordinates]
+    end
+
+    # Will reset cell on given coordinates by creating the
+    # default new one.
+    # * +coordinates+ for the newly created cell
+    def reset_cell(coordinates)
+      add_cell(generate_default_cell(coordinates))
+    end
+
+    # Will generate default cell, which will have the given
+    # coordinates, will be ediatable (fixed = false) and will be
+    # empty (value = 0)
+    # * +coordinates+ coordinates for the new cell
+    def generate_default_cell(coordinates)
+      Cell.new(coordinates, false, 0)
+    end
+
+    # Will return array of cells stored on a row with given
+    # coordinate.
+    # * +y+ coordinate of the desired row. Must be in the 0-8 interval.
+    def get_row(y)
+      fail ArgumentException,
+           'Invalid row access coordinate.' unless Coordinate.valid?(y)
+      cells.values.select { |cell| cell.coordinates.coordinate_y == y }.sort
+    end
+
+    # Will return array of cells stored in a given column of this
+    # grid.
+    # * +x+ coordinate of the desired column. Must be in the 0-8 interval.
+    def get_col(x)
+      fail ArgumentException,
+           'Invalid column access coordinate.' unless Coordinate.valid?(x)
+      cells.values.select { |cell| cell.coordinates.coordinate_x == x }.sort
+    end
+
+    # Will add new cell to the grid. If there is already a cell
+    # with the same coordintates, it will be replaced by the new
+    # one and the old one will be returned.
+    # * +cell+ cell to add
+    def add_cell(cell)
+      cells[cell.coordinates] = cell
+    end
+
+    # Will return true, it this gird is solved.
+    def solved?
+      Solver.new(self).solved?
+    end
+
+    # Will return matrix of values of this Grid.
+    def to_s
+      out = ''
+      GridFactory.new.generate_all_coordinates.each_with_index do |x, index|
+        out << get_cell(x).value.to_s << x.to_s
+        (index + 1).modulo(9).zero? ? out << "\n" : out << ' '
+      end
+      out
+    end
+  end
+end

data/lib/sudoku/solver.rb

@@ -0,0 +1,61 @@
+require 'sudoku/model/grid'
+
+module Sudoku
+  # This class provides method for solving or checking solution of the
+  # Sudoku game.
+  class Solver
+    # Will initialize this solver with given grid. Exception is thrown
+    # if the given grid is not kind of Sudoku::Grid
+    def initialize(grid)
+      fail ArgumentError,
+           'Invalid grid passed to solver' unless grid.is_a?(Grid)
+      @grid = grid
+    end
+
+    # Will check if the sudoku rules are violated, but the 0 value is
+    # ignored. Returns true if violated, false otherwise.
+    def rules_violated?
+      rows_violated? || cols_violated? || areas_violated?
+    end
+
+    # Will return true, if all cells of the grid are filled and no
+    # Sudoku rule is violated.
+    def solved?
+      !rules_violated? && grid_filled?
+    end
+
+    # Will return true, if the grid is filled, which means, that all
+    # of the values are other than 0. False otherwise.
+    def grid_filled?
+      @grid.filled?
+    end
+
+    # Will return true, if all rows are correctly solved.
+    def rows_violated?
+      (0..8).to_a.collect { |x|cells_violated?(@grid.get_row(x)) }.any?
+    end
+
+    # Will return true, if all cols are correctly solved.
+    def cols_violated?
+      (0..8).to_a.collect { |x|cells_violated?(@grid.get_col(x)) }.any?
+    end
+
+    # Will return true, if given set of cells does not contain
+    # duplicities in values other than 0.
+    # * +cells+ set of cells to check.
+    def cells_violated?(cells)
+      values = cells.select { |x| x.value != 0 }.collect(&:value)
+      values.uniq.size != values.size
+    end
+
+    # Will return true, if in some area of the grid are duplicit or
+    # illegal numbers. Returns false otherwise.
+    def areas_violated?
+      [(0..2), (3..5), (6..8)].repeated_permutation(2).each do |x, y|
+        cells = @grid.cells.select { |cell| cell.in_area(x, y) }
+        return true if cells_violated?(cells)
+      end
+      false
+    end
+  end
+end

data/lib/sudoku/version.rb

@@ -0,0 +1,4 @@
+# Version of this module.
+module Sudoku
+  VERSION = '0.0.2'
+end

data/lib/sudoku.rb

@@ -0,0 +1,8 @@
+require 'sudoku/version'
+require 'simplecov'
+SimpleCov.start
+
+# This is the Sudoku module, all code in the lib directory.
+module Sudoku
+  # All code in the lib library
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require File.expand_path('../../lib/sudoku.rb', __FILE__)
+
+# Tests for Sudoku model
+require 'sudoku/spec_helper'

data/spec/sudoku/grid_factory_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Sudoku::GridFactory do
+  GRID_FACTORY ||= Sudoku::GridFactory
+  CELL_COORDINATES ||= Sudoku::CellCoordinates
+  let(:factory) { GRID_FACTORY.new }
+
+  before do
+    factory.disable_log
+  end
+
+  it 'creates all coordinates set correctly' do
+    set = factory.generate_all_coordinates
+    expect(set.include?(CELL_COORDINATES.new(0, 0))).to be true
+    expect(set.include?(CELL_COORDINATES.new(8, 8))).to be true
+    expect(set.size).to eql(81)
+  end
+
+  context 'grid creation' do
+    let(:random_grid) { factory.create_random }
+    let(:solved_grid) { factory.create_full_grid }
+    let(:free_cell) { Sudoku::Cell.new(CELL_COORDINATES.random, false, 5) }
+
+    it 'the created solved grid does not have any free cells' do
+      invalid_cells = solved_grid.cells.values.select { |x| !x.fixed }
+      expect(invalid_cells.size).to eql(0)
+    end
+
+    it 'the random grid has no fixed cells with values other than 0' do
+      invalid = random_grid.cells.values.select { |x| !x.fixed && x.value > 0 }
+      expect(invalid.size).to eql(0)
+    end
+
+    it 'the random grid does not contains fixed cells with value = 0' do
+      invalid = random_grid.cells.values.select { |x| x.fixed && x.value == 0 }
+      expect(invalid.size).to eql(0)
+    end
+
+    it 'number of opened cells corresponds to the settings of factory' do
+      cells = random_grid.cells.values.select { |x| !x.fixed }
+      expect(cells.size).to eql(GRID_FACTORY::CELLS_TO_OPEN)
+    end
+
+    it 'parsing of bad sudoku format fails' do
+      expect { factory.parse_file('lib/version.rb') }.to raise_error
+    end
+  end
+end

data/spec/sudoku/log_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Sudoku::Logging do
+  LOGGING ||= Sudoku::Logging
+
+  let(:some_class) { Class.new.extend(Sudoku::Logging) }
+
+  before { some_class.disable_log }
+
+  it 'logger not null' do
+    expect(LOGGING::LOGGER).not_to be nil
+  end
+
+  it 'no method raises exception' do
+    expect { some_class.info('whatever') }.not_to raise_error
+    expect { some_class.error('whatever') }.not_to raise_error
+    expect { some_class.fatal('whatever') }.not_to raise_error
+    expect { some_class.disable_log }.not_to raise_error
+  end
+end

data/spec/sudoku/model/cell_coordinates_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Sudoku::CellCoordinates do
+  CELL_COORDINATES ||= Sudoku::CellCoordinates
+  COORDINATE ||= Sudoku::Coordinate
+
+  let(:cell_coordinates_5_5) { CELL_COORDINATES.new(5, 5) }
+  let(:cell_coordinates_7_7) { CELL_COORDINATES.new(7, 7) }
+  let(:cell_coordinates_3_7) { CELL_COORDINATES.new(COORDINATE.new(3), 7) }
+  let(:cell_coordinates_wrong) { CELL_COORDINATES.new(0, 9) }
+
+  it 'proper initializations' do
+    expect(cell_coordinates_5_5.coordinate_x).to eql(5)
+    expect(cell_coordinates_5_5.coordinate_y).to eql(5)
+    expect(cell_coordinates_3_7.coordinate_x).to eql(3)
+    expect(cell_coordinates_3_7.coordinate_y).to eql(7)
+    expect { cell_coordinates_wrong }.to raise_error
+  end
+
+  it 'proper eql method' do
+    expect(cell_coordinates_5_5).to eql(cell_coordinates_5_5)
+    expect(cell_coordinates_5_5.eql?(CELL_COORDINATES.new(5, 5))).to be true
+    expect(cell_coordinates_5_5).not_to eql(cell_coordinates_3_7)
+    expect(cell_coordinates_5_5).not_to eql(5)
+  end
+
+  it 'proper to_s method' do
+    expect(cell_coordinates_5_5.to_s).to eql('[5, 5]')
+  end
+
+  it 'proper hash method' do
+    expect(cell_coordinates_5_5.hash).to eql(CELL_COORDINATES.new(5, 5).hash)
+    expect(cell_coordinates_5_5.hash == cell_coordinates_3_7.hash).to be false
+  end
+end

data/spec/sudoku/model/cell_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe Sudoku::Cell do
+  CELL_COORDINATES ||= Sudoku::CellCoordinates
+  CELL ||= Sudoku::Cell
+  let(:cell_coordinates_5_5) { CELL_COORDINATES.new(5, 5) }
+  let(:cell_coordinates_7_7) { CELL_COORDINATES.new(7, 7) }
+
+  context 'basic simple cells testing' do
+    let(:test_cell) { CELL.new(cell_coordinates_5_5, false, 0) }
+    let(:custom_cell) { CELL.new(cell_coordinates_5_5, true, 5) }
+
+    it 'can create valid cell' do
+      expect { test_cell }.not_to raise_error
+      expect { custom_cell }.not_to raise_error
+    end
+
+    it 'has correct string representation' do
+      expect(test_cell.to_s).to eql('[5, 5], 0, false')
+    end
+
+    it 'increments correctly' do
+      (0..9).each do |i|
+        expect(test_cell.value).to eql(i)
+        test_cell.increment
+      end
+      expect(test_cell.value).to eql(0)
+    end
+
+    it 'decrements correctly' do
+      test_cell.decrement
+      (9.downto(0)).each do |i|
+        expect(test_cell.value).to eql(i)
+        test_cell.decrement
+      end
+      expect(test_cell.value).to eql(9)
+    end
+
+    it 'has correctly set parameters' do
+      expect(test_cell.value).to eql(0)
+      expect(test_cell.fixed).to eql(false)
+      expect(test_cell.coordinates).to eql(cell_coordinates_5_5)
+
+      expect(custom_cell.value).to eql(5)
+      expect(custom_cell.fixed).to eql(true)
+      expect(custom_cell.coordinates).to eql(cell_coordinates_5_5)
+
+      expect(custom_cell.coordinates.coordinate_x).to eql(5)
+      expect(custom_cell.coordinates.coordinate_y).to eql(5)
+
+      expect(test_cell.coordinates.coordinate_x).to eql(5)
+      expect(test_cell.coordinates.coordinate_y).to eql(5)
+    end
+
+    it 'the cells on same coordinates are equal' do
+      expect(test_cell.eql?(custom_cell)).to be true
+      expect(test_cell == custom_cell).to be true
+    end
+
+    it 'the cells with different coordinates are not equal' do
+      expect(test_cell.eql?(CELL.new(cell_coordinates_7_7))).to be false
+    end
+  end
+
+  it 'does not allow to create fixed 0 cell'  do
+    expect { CELL.new(cell_coordinates_5_5, true, 0) }.to raise_error
+  end
+
+  it 'accepts only valid coordinates' do
+    expect { CELL.new('whatever') }.to raise_error
+  end
+
+  it 'returns correct cell string representation' do
+    expect(CELL.new(cell_coordinates_5_5, false, 0).as_string).to eql('')
+    expect(CELL.new(cell_coordinates_5_5, true, 5).as_string).to eql('5')
+  end
+
+  context 'setting value to cell' do
+    let(:fixed_cell) { CELL.new(cell_coordinates_7_7, true, 5) }
+    let(:free_cell) { CELL.new(cell_coordinates_5_5, false, 0) }
+
+    it 'cant assign value to fixed cell' do
+      expect { fixed_cell.value = 5 }.to raise_error
+    end
+
+    it 'cant assign values out of interval 0-9' do
+      expect { free_cell.value = -1 }.to raise_error
+      expect { free_cell.value = 10 }.to raise_error
+    end
+
+    it 'can assign correct values' do
+      expect { free_cell.value = 0 }.not_to raise_error
+      expect { free_cell.value = 9 }.not_to raise_error
+      expect { free_cell.value = 2 }.not_to raise_error
+      expect(free_cell.value).to eql(2)
+    end
+  end
+end

data/spec/sudoku/model/coordinate_spec.rb

@@ -0,0 +1,39 @@
+require_relative 'spec_helper'
+
+describe Sudoku::Coordinate do
+  COORDINATE ||= Sudoku::Coordinate
+
+  let(:coordinate5) { COORDINATE.new(5) }
+  let(:coordinate7) { COORDINATE.new(7) }
+  let(:coordinate0) { COORDINATE.new(0) }
+  let(:coordinate8) { COORDINATE.new(8) }
+
+  it 'accepts the number and COORDINATE in the constructor' do
+    expect(COORDINATE.new(5).coordinate).to eq(5)
+    expect(COORDINATE.new(COORDINATE.new(5)).coordinate).to eq(5)
+  end
+
+  it 'returns correct string' do
+    expect(coordinate5.to_s).to eq(5.to_s)
+    expect(coordinate5.to_s).not_to eq(10.to_s)
+  end
+
+  it 'converts to_i and to_int' do
+    expect(coordinate5.to_i).to eq(5.to_i)
+    expect(coordinate5.to_int).to eq(5.to_int)
+    expect(coordinate5.to_i).not_to eq(10.to_i)
+  end
+
+  it 'compares with coordinate and number' do
+    expect(coordinate5).to be < coordinate7
+    expect(coordinate7).to be > coordinate5
+    expect(coordinate5).to be == COORDINATE.new(5)
+  end
+
+  it 'accepts only vales from the interval 0-8 inclusive' do
+    expect { COORDINATE.new(10) }.to raise_error ArgumentError
+    expect { COORDINATE.new(-10) }.to raise_error ArgumentError
+    expect { COORDINATE.new(0) }.not_to raise_error
+    expect { COORDINATE.new(8) }.not_to raise_error
+  end
+end

data/spec/sudoku/model/empty_grid.txt

@@ -0,0 +1,9 @@
+0[0, 0] 0[1, 0] 0[2, 0] 0[3, 0] 0[4, 0] 0[5, 0] 0[6, 0] 0[7, 0] 0[8, 0]
+0[0, 1] 0[1, 1] 0[2, 1] 0[3, 1] 0[4, 1] 0[5, 1] 0[6, 1] 0[7, 1] 0[8, 1]
+0[0, 2] 0[1, 2] 0[2, 2] 0[3, 2] 0[4, 2] 0[5, 2] 0[6, 2] 0[7, 2] 0[8, 2]
+0[0, 3] 0[1, 3] 0[2, 3] 0[3, 3] 0[4, 3] 0[5, 3] 0[6, 3] 0[7, 3] 0[8, 3]
+0[0, 4] 0[1, 4] 0[2, 4] 0[3, 4] 0[4, 4] 0[5, 4] 0[6, 4] 0[7, 4] 0[8, 4]
+0[0, 5] 0[1, 5] 0[2, 5] 0[3, 5] 0[4, 5] 0[5, 5] 0[6, 5] 0[7, 5] 0[8, 5]
+0[0, 6] 0[1, 6] 0[2, 6] 0[3, 6] 0[4, 6] 0[5, 6] 0[6, 6] 0[7, 6] 0[8, 6]
+0[0, 7] 0[1, 7] 0[2, 7] 0[3, 7] 0[4, 7] 0[5, 7] 0[6, 7] 0[7, 7] 0[8, 7]
+0[0, 8] 0[1, 8] 0[2, 8] 0[3, 8] 0[4, 8] 0[5, 8] 0[6, 8] 0[7, 8] 0[8, 8]

data/spec/sudoku/model/grid_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Sudoku::Grid do
+  CELL_COORDINATES ||= Sudoku::CellCoordinates
+  CELL ||= Sudoku::Cell
+  GRID ||= Sudoku::Grid
+
+  let(:cell_coordinates_5_5) { CELL_COORDINATES.new(5, 5) }
+  let(:cell_coordinates_7_7) { CELL_COORDINATES.new(7, 7) }
+  let(:fixed_cell) { CELL.new(cell_coordinates_5_5, true, 5) }
+  let(:free_cell) { CELL.new(cell_coordinates_7_7, false, 0) }
+  let(:same_free_cell) { CELL.new(cell_coordinates_7_7, true, 7) }
+  let(:test_grid) { GRID.new }
+  let(:factory) { Sudoku::GridFactory.new }
+
+  before { factory.disable_log }
+
+  context 'adding elements' do
+    it 'adds elements' do
+      test_grid.add_cell(fixed_cell)
+      cell_stored = test_grid.get_cell(cell_coordinates_5_5)
+      expect(cell_stored).not_to be_nil
+      expect(cell_stored.value).to eql(5)
+      expect(cell_stored.fixed).to be true
+      expect(cell_stored.coordinates == cell_coordinates_5_5).to be true
+    end
+
+    it 'replaces element which exists' do
+      test_grid.add_cell(free_cell)
+      test_grid.add_cell(same_free_cell)
+      cell_stored = test_grid.get_cell(cell_coordinates_7_7)
+
+      expect(cell_stored.value).to eql(same_free_cell.value)
+      expect(cell_stored.coordinates).to eql(same_free_cell.coordinates)
+      expect(cell_stored.fixed).to eql(same_free_cell.fixed)
+    end
+  end
+
+  context 'getting elements' do
+    let(:grid) { Sudoku::GridFactory.new.create_random }
+
+    it 'returns default element, when element does not exist' do
+      cell_stored = test_grid.get_cell(cell_coordinates_7_7)
+      default_cell = test_grid.generate_default_cell(cell_coordinates_7_7)
+
+      expect(cell_stored.value).to eql(default_cell.value)
+      expect(cell_stored.coordinates).to eql(default_cell.coordinates)
+      expect(cell_stored.fixed).to eql(default_cell.fixed)
+    end
+  end
+
+  context 'misc operations' do
+    let(:grid) { factory.create_random }
+    let(:full_grid)  { factory.create_full_grid }
+    let(:invalid_grid) do
+      grid = factory.create_full_grid
+      grid.add_cell(CELL.new(CELL_COORDINATES.new(0, 0), false, 5))
+      grid.add_cell(CELL.new(CELL_COORDINATES.new(1, 0), false, 5))
+      grid
+    end
+
+    it 'test filled properly' do
+      expect(GRID.new.filled?).to be false
+      expect(Sudoku::GridFactory.new.create_full_grid.filled?).to be true
+    end
+
+    it 'test grid violation' do
+      expect(full_grid.rules_violated?).to be false
+      expect(invalid_grid.rules_violated?).to be true
+    end
+
+    it 'test grid solved' do
+      expect(full_grid.solved?).to be true
+      expect(invalid_grid.solved?).to be false
+      expect(grid.solved?).to be false
+    end
+
+    it 'resets cell' do
+      default_cell = grid.generate_default_cell(cell_coordinates_5_5)
+      grid.reset_cell(default_cell.coordinates)
+      reset_cell = grid.get_cell(default_cell.coordinates)
+
+      expect(default_cell.coordinates).to eql(reset_cell.coordinates)
+      expect(default_cell.value).to eql(reset_cell.value)
+      expect(default_cell.fixed).to eql(reset_cell.fixed)
+      expect(default_cell == reset_cell).to be true
+    end
+
+    it 'has correct to_s method' do
+      path = 'spec/sudoku/model/empty_grid.txt'
+      empty_grid_s = GRID.new.to_s
+      (File.open(path).zip empty_grid_s.lines).each do |x, y|
+        expect(x).to eql(y)
+      end
+    end
+  end
+end

data/spec/sudoku/model/spec_helper.rb

@@ -0,0 +1,3 @@
+# This will add all files in the model directory
+require 'require_all'
+require_all File.expand_path('../../../../lib/sudoku/model', __FILE__)

data/spec/sudoku/solver_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Sudoku::Solver do
+  SOLVER ||= Sudoku::Solver
+  CELL ||= Sudoku::Cell
+  CELL_COORDINATES ||= Sudoku::CellCoordinates
+
+  let(:factory) { Sudoku::GridFactory.new }
+
+  before do
+    factory.disable_log
+  end
+
+  context 'cells set solving' do
+    let(:solver) { SOLVER.new(factory.create_full_grid) }
+    let(:solvable) do
+      (1..9).to_a.collect { |x| CELL.new(CELL_COORDINATES.random, false, x) }
+    end
+
+    it 'solves the 9 cells set' do
+      expect(solver.cells_violated?(solvable)).to be false
+    end
+
+    it 'does not accept invalid set' do
+      solvable[5].value = 4
+      expect(solver.cells_violated?(solvable)).to be true
+    end
+  end
+end

data/spec/sudoku/spec_helper.rb

@@ -0,0 +1,3 @@
+require_relative 'model/spec_helper'
+require 'require_all'
+require_all File.expand_path('../../../lib/sudoku', __FILE__)

data/spec/sudoku_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+# Sudoku test
+describe Sudoku do
+  it 'prototype test does not fail' do
+    true
+  end
+
+  it 'version must not be nil' do
+    expect(Sudoku::VERSION).not_to be_nil
+  end
+end

data/sudoku.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sudoku/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sudoku_bad"
+  spec.version       = Sudoku::VERSION
+  spec.authors       = ["Tomáš Hauk"]
+  spec.email         = ["hauktoma@fit.cvut.cz"]
+  spec.summary       = %q{This is a basic gem for Sudoku program.}
+  spec.description   = %q{Dont use this software.}
+  spec.homepage      = ""
+  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 "require_all"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "green_shoes"
+end