sudoku_bad 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 60e7638a73b91eb4632f23823db6505625073b68
+  data.tar.gz: fede49421992f27c772754d13db856f4ed4d1691
+SHA512:
+  metadata.gz: f23f2209b04e2c46c1535eb48d28ab56f9292715046bd889427aeb26724d7f145508f98b60756a5bcb78ef11dcbb71d1050c594fb3b4d568256f85da111e709f
+  data.tar.gz: 8d778460d01f879410a55cab84dbb46e7de8a34c78070a822c3c092965033890ed9f47164cef7e88caa827bdb7f6c5ca67f620d970eccfd245e66d254f881b38

data/.gitignore

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

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,21 @@
+guard :rspec, cmd: 'bundle exec rspec --color --format documentation' do
+  # watch /lib/ files
+  watch(%r{^lib/(.+).rb$}) do |m|
+    "spec/#{m[1]}_spec.rb"
+  end
+
+  # watch /lib/sudoku files
+  watch(%r{^lib/sudoku/(.+).rb$}) do |m|
+    "spec/sudoku/#{m[1]}_spec.rb"
+  end
+
+  # watch /lib/sudoku/model files
+  watch(%r{^lib/sudoku/model/(.+).rb$}) do |m|
+    "spec/sudoku/model/#{m[1]}_spec.rb"
+  end
+
+  # watch /spec/ files
+  watch(%r{^spec/(.+).rb$}) do |m|
+    "spec/#{m[1]}.rb"
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Tomáš Hauk
+
+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,35 @@
+# Sudoku
+
+This program was created as semestral work in MI-RUB at FIT CVUT
+in Prague, in winter semester of 2014. Does not do anything
+useful and the author recommends not using anything from this
+crappy piece of software.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sudoku'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sudoku
+
+## Usage
+
+Run the 'sudoku' program, which will start the GUI for the sudoku
+game.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/sudoku/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,11 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+# Default directory to look in is `/specs`
+# Run with `rake spec`
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = ['--color', '--format', 'documentation']
+end
+
+task :default => :spec
+

data/bin/sudoku

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require 'green_shoes'
+require 'sudoku/main_window'
+
+# Will start the GUI
+Shoes.app(title: "My calculator", width: 200, height: 240)
+
+

data/data/sudoku11496.txt

@@ -0,0 +1 @@
+926548713541637289378291456815463972697152834432879561759326148283714695164985327

data/data/sudoku16576.txt

@@ -0,0 +1 @@
+648195723539472186217386495874931562951627834362854917793248651125769348486513279

data/data/sudoku28276.txt

@@ -0,0 +1 @@
+742589163596713428831624795987351642254976831163248957318462579679135284425897316

data/data/sudoku8134.txt

@@ -0,0 +1 @@
+493128675568947231172653894239816457817435962654279318746381529981562743325794186

data/lib/sudoku/grid_factory.rb

@@ -0,0 +1,93 @@
+require 'sudoku/model/grid'
+require 'sudoku/model/cell_coordinates'
+require 'sudoku/model/cell'
+require 'sudoku/solver'
+require 'sudoku/log'
+
+module Sudoku
+  # This class handles the creation of the Grid classes.
+  class GridFactory
+    include Logging
+
+    # How many cells will be opened by this factory.
+    CELLS_TO_OPEN = 2
+    # Path to directory, where the sample grids are stored.
+    SAMPLES_PATH = 'data'
+    # Number of attempts for parsing sample sudoku file.
+    PARSE_ATTEMPTS = 5
+
+    # Will return path of  one of the stored sudoku files in this project.
+    def sample_file
+      "#{SAMPLES_PATH}/#{Dir.entries(SAMPLES_PATH)
+                            .select { |x| File.extname(x) == '.txt' }
+                            .sample}"
+    end
+
+    # Will try to parse file on given path and will return
+    # initialized Grid on success. Will return nil on fail.
+    # * +path+ path to file to parse.
+    def parse_file(path)
+      info "Trying to parse file #{path} with sample sudoku."
+      File.open(path).each_with_index do |line, index|
+        info "Parsing line #{index}"
+        grid = parse_line(line)
+        return grid unless grid.nil?
+      end
+      nil
+    end
+
+    # Will try to parse given line, where the Sudoku sample
+    # should be. Will return initialized instanceof Grid on
+    # success, nil otherwise.
+    # * +line+ to parse
+    def parse_line(line)
+      grid = Grid.new
+      generate_all_coordinates.zip(line.split('')).each do |coordinate, value|
+        grid.add_cell(Cell.new(coordinate, true, value.to_i))
+      end
+      grid
+    end
+
+    # This method will create random, simple and solvable sudoku
+    # grid.
+    def create_random
+      result = create_full_grid
+      result = create_full_grid until Sudoku::Solver.new(result).solved?
+      randomize_grid(result)
+    end
+
+    # This method will create full (solved) Sudoku grid, where
+    # all cells are filled and fixed.
+    def create_full_grid
+      grid = nil
+      (0..PARSE_ATTEMPTS).each do |i|
+        info "Attempt #{i}/#{PARSE_ATTEMPTS} to parse grid."
+        grid = parse_file(sample_file)
+        return grid unless grid.nil?
+      end
+      fail IOError, "Failed in creating sample Sudoku after #{i} attempts"
+    end
+
+    # Will take full solved grid, and will randomly fix some
+    # cells and clean others.
+    # * +grid+ grid to randomize.
+    def randomize_grid(grid)
+      (1..CELLS_TO_OPEN).each do
+        cell = grid.random_cell
+        cell = grid.random_cell until cell.fixed
+        grid.add_cell(Cell.new(cell.coordinates, false, 0))
+      end
+      grid
+    end
+
+    # Will generate all possible coordinates, which can exist in
+    # the sudoku grid.
+    def generate_all_coordinates
+      result = []
+      (0..8).to_a.repeated_permutation(2).to_a.each do
+        |x| result << Sudoku::CellCoordinates.new(x[0], x[1])
+      end
+      result.sort
+    end
+  end
+end

data/lib/sudoku/log.rb

@@ -0,0 +1,30 @@
+require 'singleton'
+require 'logger'
+
+module Sudoku
+  # Module for logging functionality
+  module Logging
+    # Logger for use in the Sudoku classees
+    LOGGER = Logger.new(STDOUT)
+
+    # Will log info message
+    def info(message)
+      LOGGER.info(message)
+    end
+
+    # Will log error message
+    def error(message)
+      LOGGER.error(message)
+    end
+
+    # Will log fatal message
+    def fatal(message)
+      LOGGER.error(message)
+    end
+
+    # Will disable all logging except for fatal errors.
+    def disable_log
+      LOGGER.level = Logger::FATAL
+    end
+  end
+end

data/lib/sudoku/main_window.rb

@@ -0,0 +1,128 @@
+require 'green_shoes'
+require 'sudoku/grid_factory'
+require 'sudoku/log'
+
+module Sudoku
+  # This class represents main window for the Sudoku GUI.
+  class MainWindow < Shoes
+    include Logging
+    url '/', :index
+
+    # Will initialize the model
+    def init_model
+      info 'Initializing model'
+      @grid = Sudoku::GridFactory.new.create_random
+      info "Generated grid\n#{@grid}"
+    end
+
+    # This will create new sudoku and will render main page
+    def index
+      info 'Rendering GUI'
+      init_model
+      flow width: 1.0, height: 0.8 do
+        render_grid
+      end
+      flow width: 1.0, height: 0.2 do
+        render_help
+      end
+      info 'GUI rendered'
+    end
+
+    # Will render basic help text
+    def render_help
+      caption 'Help'
+      para ' - Left click on the cell will select and increment the cell.'
+      para ' - Right click on the cell will select and decrement the cell.'
+      para ' - When cell is selected, you can use number keys to fill it.'
+    end
+
+    # This will render the grid for sudoku.
+    def render_grid
+      info 'Rendering grid'
+      flow width: 700, heiht: 700 do
+        @grid.cells.values.sort.each { |x| render_cell(x) }
+      end
+      keypress { |key| handle_key_press(key) }
+      info 'Grid rendered.'
+    end
+
+    # If there is some selected cell and the number is pressed,
+    # the number will be used as input to the cell.
+    def handle_key_press(key)
+      info "Pressed key #{key}"
+      return if @selected.nil? || !('0'..'9').include?(key)
+      flow, cell = @selected
+      cell.value = key.to_i
+      flow.clear { fill_cell(cell) }
+      info "Value of cell #{cell.coordinates} set to #{cell.value}"
+      handle_end_game
+    end
+
+    # Will render particular cell.
+    def render_cell(cell)
+      cell_flow = flow width: 0.1111  do
+        fill_cell(cell)
+      end
+      cell_flow.click { |button| handle_cell_click(cell, cell_flow, button) }
+    end
+
+    # Will handle click on the cell
+    def handle_cell_click(cell, flow, button)
+      info "Detected click on the cell #{cell}"
+      cell.increment if button == 1
+      cell.decrement if button == 3
+      reset_selected_flow(flow, cell)
+      flow.clear { fill_cell(cell) }
+      handle_end_game
+    end
+
+    # Will reset selected flow and will set the selected to the
+    # new values.
+    # * +new_flow+ new selected flow
+    # * +new_cell+ new selected cell
+    def reset_selected_flow(new_flow, new_cell)
+      return @selected if new_cell.fixed
+      return @selected = [new_flow, new_cell] if @selected.nil?
+      old_flow, old_cell = @selected
+      @selected = [new_flow, new_cell]
+      old_flow.clear { fill_cell(old_cell) }
+    end
+
+    # Will fill the given container with cell content.
+    def fill_cell(cell)
+      background cell_background(cell)
+      strokewidth get_stroke_width(cell)
+      border get_cell_border(cell)
+      banner cell.as_string, align: 'center' if cell.fixed
+      banner cell.as_string, align: 'center', weight: 'bold' unless cell.fixed
+    end
+
+    # Will determine border of the cell.
+    def get_cell_border(cell)
+      return black if @selected.nil? || @selected[1] != cell
+      red
+    end
+
+    def get_stroke_width(cell)
+      return 1 if @selected.nil? || @selected[1] != cell
+      2
+    end
+
+    # Will determine and return background for cell
+    def cell_background(cell)
+      color1 = rgb(108, 140, 236)
+      color2 = rgb(213, 152, 108)
+      x, y = cell.coordinates.coordinate_x, cell.coordinates.coordinate_y
+      if x.coordinate.between?(3, 5)
+        y.coordinate.between?(3, 5) ? (return color1) : (return color2)
+      else
+        y.coordinate.between?(3, 5) ? (return color2) : (return color1)
+      end
+    end
+
+    # Will check, if the grid is solved. If so, will show alert.
+    def handle_end_game
+      alert 'Grid successfully solved!' if @grid.solved?
+    end
+  end
+end

data/lib/sudoku/model/cell.rb

@@ -0,0 +1,95 @@
+module Sudoku
+  # Represents single Cell in the Sudoku grid.
+  class Cell
+    include Comparable
+    attr_accessor :value, :fixed, :coordinates
+
+    # Initializes this cell. It is not possible to initialize
+    # fixed cell with value 0.
+    # * +fixed+ boolean value, which indicates if this cell is fixed
+    # * +coordinates+ X Y coordinates of this cell.
+    # * +value+ numerical value of this cell. Default set to 0.
+    def initialize(coordinates, fixed = false, value = 0)
+      fail ArgumentError,
+           'Cant initialize fixed cell with value 0' if fixed && value == 0
+
+      fail ArgumentError,
+           'Wrong coordinate parameter.' unless
+              coordinates.respond_to?(:coordinate_x) &&
+              coordinates.respond_to?(:coordinate_y)
+
+      self.value = value
+      @fixed = fixed
+      @coordinates = CellCoordinates.new(coordinates.coordinate_x,
+                                         coordinates.coordinate_y)
+    end
+
+    # Will return value of this cell in the correct string
+    # format. As an empty string, if the value is 0, or as value
+    # string represetation.
+    def as_string
+      return '' unless @value != 0
+      @value.to_s
+    end
+
+    # Will increment cell value, if the cell is not fixed. Will
+    # reset on overflow. Returns new value.
+    def increment
+      return @value if @fixed
+      @value += 1
+      @value = 0 if @value > 9
+      @value
+    end
+
+    # Will return true, if coordinates of this cell belongs to
+    # area given by two coordinate ranges.
+    # * +x+ range of x coordinates
+    # * +y+ range of y coordinates
+    def in_area(x, y)
+      @coordinates.in_area(x, y)
+    end
+
+    # Will decrement cell value, if the cell is not fixed. Will
+    # reset on underflow. Returns new value.
+    def decrement
+      return @value if @fixed
+      @value -= 1
+      @value = 9 if @value < 0
+      @value
+    end
+
+    # The cells are equal, if they have the same coordinate, no
+    # matter the value and fixed tag.
+    def eql?(other)
+      return false unless other.respond_to?(:coordinates)
+      @coordinates.eql?(other.coordinates)
+    end
+
+    # Same as eql?
+    def ==(other)
+      eql?(other)
+    end
+
+    def to_s
+      "#{@coordinates}, #{@value}, #{fixed}"
+    end
+
+    def <=>(other)
+      @coordinates <=> other.coordinates
+    end
+
+    # Will set the value of this cell. New value must be in the
+    # interval of 0 - 9, where 0 means, that the cell is not
+    # filled yet. This method will fail, if the attribute fixed
+    # is set to true.
+    # * +value+ new value to set to this cell
+    def value=(value)
+      fail ArgumentError,
+           'Cant assign new value to fixed value cell.' if @fixed
+      fail ArgumentError,
+           'Cell initialization value out of interval 0-9' if
+            value < 0 || value > 9
+      @value = value
+    end
+  end
+end

data/lib/sudoku/model/cell_coordinates.rb

@@ -0,0 +1,54 @@
+require 'sudoku/model/coordinate'
+
+module Sudoku
+  # Represents a two dimensional coordinates in the Sudoku grid.
+  class CellCoordinates
+    include Comparable
+    attr_reader :coordinate_x, :coordinate_y
+
+    # Will initialize this cell coordinate.
+    # * +x+ horizontal coordinate.
+    # * +y+ vertical coordinate.
+    def initialize(x, y)
+      @coordinate_x = Sudoku::Coordinate.new(x)
+      @coordinate_y = Sudoku::Coordinate.new(y)
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        @coordinate_x == other.coordinate_x &&
+        @coordinate_y == other.coordinate_y
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      @coordinate_x.coordinate ^ @coordinate_y.coordinate # XOR, from the doc
+    end
+
+    def <=>(other)
+      return @coordinate_y <=> other.coordinate_y if
+        @coordinate_y != other.coordinate_y
+      @coordinate_x <=> other.coordinate_x
+    end
+
+    # Will return this coordinate in the format [x, y]
+    def to_s
+      "[#{coordinate_x}, #{coordinate_y}]"
+    end
+
+    # Will return true, if this coordinate belongs to area given
+    # by two ranges of coordinates.
+    # * +x+ range of x coordinates to accept.
+    # * +y+ range of y coordinates to accept.
+    def in_area(x, y)
+      return true if x.include?(@coordinate_x) && y.include?(@coordinate_y)
+      false
+    end
+
+    # Will return randomly generated coordinate.
+    def self.random
+      CellCoordinates.new(Random.rand(0..8), Random.rand(0..8))
+    end
+  end
+end

data/lib/sudoku/model/coordinate.rb

@@ -0,0 +1,61 @@
+module Sudoku
+  # Represents a cell coordinate in one dimension of the Sudoku
+  # grid.
+  class Coordinate
+    include Comparable
+
+    attr_reader :coordinate
+
+    # Will initialize this coordinate.
+    # * +coordinate+ coordinate value, which must be in the 0-8 interval.
+    def initialize(coordinate)
+      fail ArgumentError,
+           "Coordinate value must be 0-8, value #{coordinate} given." unless
+            coordinate_valid?(coordinate)
+
+      @coordinate = coordinate.to_i
+    end
+
+    # Will check if given number can be used as the valid coordinate,
+    # which means, that it is a number in the interval
+    # 0-8 inclusive. True is returned if the coordinate is valid,
+    # false otherwise.
+    # * +coordinate+ coordinate value to check
+    def coordinate_valid?(coordinate)
+      Coordinate.valid?(coordinate)
+    end
+
+    # Will return true, if the given coordinate is between 0-8
+    # interval, inclusive.
+    def self.valid?(coordinate)
+      return true if coordinate >= 0 && coordinate < 9
+      false
+    end
+
+    def to_s
+      @coordinate.to_s
+    end
+
+    # Will convert this coordinate to integer.
+    def to_i
+      @coordinate
+    end
+
+    # Will convert this coordinate to integer.
+    def to_int
+      to_i
+    end
+
+    # Compares this cooridnate with the other one.
+    def <=>(other)
+      return @coordinate <=> other.coordinate if other.respond_to?(:coordinate)
+      @coordinate <=> other.to_i
+    end
+
+    # Will check, if the given element represents the same
+    # one-dimensional coordiante.
+    def eql?(other)
+      @coordinate == other.to_i
+    end
+  end
+end