grid_struct 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8123cc6cecee6f31395c03f4f6bb71d097ac4fd1
+  data.tar.gz: 8a620e7b2af1da9daa5bdb595c388c535a14c16d
+SHA512:
+  metadata.gz: 64a7448a8fb6b4273d5dcf61d7625f523c5db7b9b97cc26cf66b8580a4df4c2cc2d7a28f4e785c82edd811ed305106be57c2768b1da0a909925dd600dfdae75a
+  data.tar.gz: 286fe7c82704872ecc924f2c414f5b0089b607623e4c2fecb79ee200ac547f3f7f7dfd3cde17e5c5755a9f5bd541f66f6df665f12d0b9288cc7fa7b34f811141

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,17 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+# 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/rsspec' (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 separetly)
+#  * 'just' rspec: 'rspec'
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Samuel Molinari
+
+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,326 @@
+# GridStruct
+
+Manipulate grid like structure in Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'grid_struct'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install grid_struct
+
+## Usage
+
+### Create a GridStruct
+
+In order to create a grid, you have to pass a 2 arguments:
+
+- ``rows``: the number of rows your grid has (the height of the grid)
+- ``columns``: the number columns your grid has (the width of the grid)
+
+```ruby
+rows = 9
+columns = 5
+
+# Create a grid of size 5x9
+grid = GridStruct.new(rows, columns)
+
+grid.size # => 45
+grid.columns # => 5
+grid.rows # => 9
+```
+
+It is possible to initialize the array with pre-set values.
+The 3rd argument must be an array.
+
+If we want to initialize the following grid:
+
+```
++---+---+---+
+| X | O | O |
++---+---+---+
+| X | x | O |
++---+---+---+
+| O | X | O |
++---+---+---+
+
+```
+
+Use the following array structure:
+
+```ruby
+#           +-----------+-----------+-----------+
+#           |   ROW 0   |   ROW 1   |   ROW 2   |
+# +---------+-----------+-----------+-----------+
+# | COLUMNS | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 | 2 |
+grid_data = ['X','O','O','X','X','O','O','X','O']
+
+tic_tac_toe = GridStruct.new(3, 3, grid_data)
+```
+
+``GridStruct`` actually store your values extactly the same way, in a 1-dimentional array.
+
+### Basics
+
+Now you know how to create grids, it's time to learn how to use our new data structure.
+
+#### Read the data store
+
+As mentionned above, your data are stored in a 1-dimentional array.
+
+```ruby
+tic_tac_toe.store # => ["X","O","O","X","X","O","O","X","O"]
+
+GridStruct.new(9,9).store # => []
+```
+
+As you can see, the ``store`` always starts as an empty array unless you decide to pre-fill the grid.
+
+#### Set value
+
+To set a value, pass the row and column you want to fill, and a block that will return the value
+
+```
+GridStruct#set(row, column) { value }
+```
+
+```ruby
+sudoku_grid = GridStruct.new(9,9)
+
+sudoku_grid.set(0,0) { 'Hello World' }
+sudoku_grid.store # => ["Hello World"]
+
+sudoku_grid.set(1,0) { 'Row: 1, Col: 0' }
+sudoku_grid.store # => ["Hello World",nil,nil,nil,nil,nil,nil,nil,"Row: 1, Col: 0"]
+```
+
+#### Get value
+
+To get a value at a specific coordinate, use th ``get`` method.
+
+```
+GridStruct#get(row, column) # => value
+```
+
+```ruby
+sudoku_grid.get(1,0) # => "Row: 1, Col: 0"
+```
+
+### Iterate
+
+You can iterate through the grid using the each method
+
+```
+GridStruct#each { |value, row, column| # Do something }
+```
+
+### Mass update
+
+#### Grid
+
+Incase you need to update each element within the grid, use the ``map!`` method
+
+```
+GridStruct#map! { |value, row, column| # Return new value  }
+```
+
+```ruby
+grid = GridStruct.new(3,3)
+grid.map! { |value, row, column| (row * grid.columns) + column }
+
+grid.store # => [0,1,2,3,4,5,6,7,8]
+```
+
+#### Row
+
+You can update a specific row if needed, for example, if we want to update the middle row
+
+```
+GridStruct#map_row! { |value, column| # Return new value  }
+```
+
+```
+                      +---+---+---+
+                      | 0 | 1 | 2 |
+                      +---+---+---+
+ Update this row  →   | 3 | 4 | 5 |
+                      +---+---+---+
+                      | 6 | 7 | 8 |
+                      +---+---+---+
+```
+
+```ruby
+grid.map_row!(1) { |value| value * 10 }
+
+grid.store # => [0,1,2,30,40,50,6,7,8]
+```
+
+
+#### Column
+
+You can update a specific row if needed, for example, if we want to update the middle row
+
+```
+GridStruct#map_column! { |value, row| # Return new value  }
+```
+
+```
+     Update this columns
+              ↓
+    +---+---+---+
+    | 0 | 1 | 2 |
+    +---+---+---+
+    | 3 | 4 | 5 |
+    +---+---+---+
+    | 6 | 7 | 8 |
+    +---+---+---+
+```
+
+```ruby
+grid.map_column!(2) { |value| value * 10 }
+
+grid.store # => [0,1,20,3,4,50,6,7,80]
+```
+
+### Selectors
+
+Selector gives you access to line of values within the grid, and allows you to
+only act on that line. Each selector return a (or an array of) GridStruct::Selector.
+
+#### Overview
+
+A selector has the following instances:
+
+- ``grid``: The grid it is selecting from
+- ``indexes``: An array of indexes mapping to the selected values in the grid store
+
+```ruby
+grid = GridStruct.new(3,3)
+
+grid.map! do |value, row, column|
+  (row * grid.columns + column) * 10
+end
+
+grid.row(0) # => #<GridStruct::Selector:0x007fb3d11decf0 @grid=#<GridStruct:0x007fb3d15541f0 @columns=3, @rows=3, @store=[0, 10, 20, 30, 40, 50, 60, 70, 80]>, @indexes=[0, 1, 2]>
+```
+
+You can retrieve and update values using ``[]``. It will map the action to the grid.
+
+```ruby
+first_row = grid.row(0)
+
+first_row.to_a # => [0,10,20]
+
+first_row[0] # => 0
+first_row[1] # => 10
+first_row[2] # => 20
+
+first_row[0] = -100
+
+grid.to_a # => [-100,10,20,30,40,50,60,70,80]
+
+```
+
+#### Row
+
+To select a specific row, use the method ``row``
+
+```
+GridStruct#row(row_number)
+```
+
+```ruby
+rows = []
+
+# Fetch selector for every rows
+grid.rows.times.each do |row_index|
+  rows[row_index] = grid.row(row_index)
+end
+```
+
+#### Column
+
+To select a specific column, use the method ``column``
+
+```
+GridStruct#column(column_number)
+```
+
+```ruby
+columns = []
+
+# Fetch selector for every columns
+grid.columns.times.each do |column_index|
+  columns[column_index] = grid.column(column_index)
+end
+```
+
+#### Diagonals
+
+The diagonals retrieval works slightly differently from the two previous methods.
+In order to retrieve diagonals, you must provide the coordinates of a cell in the grid. This will retrieve the diagonals that cross through that specific cell.
+The returned array can be of size 0 (no diagonals found, for example, in a grid of size 1), 1 (when retrieving diagonals from the corners of the grid) or 2.
+
+```
+GridStruct#diagonals(1,1) # => [#<GridStruct::Selector ...>, #<GridStruct::Selector ...>]
+```
+
+```ruby
+diagonals = grid.diagonals(1,1)
+
+diagonals.first.to_a # => [0,40,80]
+diagonals.last.to_a # => [30,40,60]
+
+corner_diagonal = grid.diagonals(0,0) # fetch diagonals from top left corner
+
+corner_diagonal.size # => 1
+corner_diagonal.first.to_a # => [0,40,80]
+```
+
+#### Slice
+
+Imagine a slice as a projection of a section of your grid.
+Use the ``slice`` method to access a single slice.
+
+```
+GridStruct#slice(slice_index, rows: slice_rows, columns: slice_columns) # => #<GridStruct::Selector ...>
+```
+
+In the following example, we are manipulating a sudoku grid, and we want to access the middle 3x3 square
+
+```ruby
+sudoku_grid = GridStruct.new(9,9)
+
+sudoku_grid.map! do |v, r, c|
+  (r * sudoku_grid.columns) + c + 1
+end
+
+sudoku_grid.slice(4, rows: 3, columns: 3) # => #<GridStruct:0x007fb3d16e4e70 @columns=3, @rows=3, @store=[31, 32, 33, 40, 41, 42, 49, 50, 51]>
+```
+
+Use the ``each_slice`` method to go through each slices
+
+```
+GridStruct#each_slice(slice_rows,slice_columns) { |slice, slice_index| # Do something }
+```
+
+```ruby
+sudoku_grid.each_slice(3,3) do |slice, index|
+  # Do something
+end
+```
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec

data/grid_struct.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'grid_struct/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "grid_struct"
+  spec.version       = GridStruct::VERSION
+  spec.authors       = ["Samuel Molinari"]
+  spec.email         = ["samuel@molinari.me"]
+  spec.description   = %q{Grid data structure}
+  spec.summary       = %q{Handle a grid data structure}
+  spec.homepage      = ""
+  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 "guard"
+  spec.add_development_dependency "guard-rspec"
+end

data/lib/grid_struct/selector.rb

@@ -0,0 +1,38 @@
+class ::GridStruct::Selector
+
+  attr_reader :grid, :indexes, :rows, :columns
+
+  def initialize(grid,*indexes)
+    @grid = grid
+    @indexes = indexes.freeze
+  end
+
+  def dimensions(rows,columns)
+    @rows = rows
+    @columns = columns
+    return self
+  end
+
+  def [](i)
+    mapped_index = @indexes[i]
+    mapped_index.nil? ? nil : @grid.store[mapped_index]
+  end
+
+  def []=(i,value)
+    mapped_index = @indexes[i]
+    @grid.store[mapped_index] = value unless mapped_index.nil?
+  end
+
+  def to_a
+    @indexes.size.times.map do |i|
+      self[i]
+    end
+  end
+
+  def to_grid(rows = nil,columns = nil)
+    rows ||= @rows
+    columns ||= @columns
+    GridStruct.new(rows,columns,to_a)
+  end
+
+end

data/lib/grid_struct/version.rb

@@ -0,0 +1,3 @@
+class GridStruct
+  VERSION = "0.0.1"
+end

data/lib/grid_struct.rb

@@ -0,0 +1,186 @@
+require 'grid_struct/version'
+require 'grid_struct/selector'
+
+class GridStruct
+
+  attr_reader :store,
+              :rows,
+              :columns
+
+  def initialize(rows, columns, store = [])
+    @rows = rows
+    @columns = columns
+    @store = store || []
+  end
+
+  def set(row,column)
+    @store[get_index(row,column)] = yield
+  end
+
+  def map!
+    size.times.map do |index|
+      value = @store[index]
+      row_column = get_row_column_at(index)
+      @store[index] = yield(value, row_column[:row], row_column[:column])
+    end
+    return self
+  end
+
+  def map_row!(n)
+    @columns.times.each do |column|
+      index = get_index(n,column)
+      value = @store[index]
+      @store[index] = yield(value,column)
+    end
+    return self
+  end
+
+  def map_column!(n)
+    @rows.times.each do |row|
+      index = get_index(row,n)
+      value = @store[index]
+      @store[index] = yield(value,row)
+    end
+    return self
+  end
+
+  def each
+    @store.fill(nil,@store.size...size).each.with_index do |value, index|
+      row_column = get_row_column_at(index)
+      yield(value,row_column[:row],row_column[:column])
+    end
+  end
+
+  def each_slice(rows,columns)
+    sub_rows = (@rows / rows.to_f).ceil
+    sub_columns = (@columns / columns.to_f).ceil
+
+    sub_rows.times.each do |sub_row|
+      sub_columns.ceil.times.each do |sub_column|
+
+        index = sub_column + (sub_row * sub_columns)
+        yield(slice(index, rows: rows, columns: columns), index)
+
+      end
+    end
+  end
+
+  def get(row,column)
+    @store[get_index(row,column)]
+  end
+
+  ##
+  # TODO Improve
+  def slice(index,dimensions)
+    rows = dimensions[:rows]
+    columns = dimensions[:columns]
+    sub_columns = (@columns / columns.to_f).ceil
+
+    sub_row = index / sub_columns
+    sub_column = index - (sub_row * sub_columns)
+
+    indexes = []
+    rows.times.each do |r|
+      start_index = (r * @columns) +
+                    (sub_row * rows * @columns) +
+                    (sub_column * columns)
+      end_index = start_index + columns
+
+      start_row = get_row_column_at(start_index)[:row]
+      end_row = get_row_column_at(end_index)[:row]
+
+      if start_row != end_row
+        extras = [0,(end_index - @columns)].max % @columns
+        end_index -= extras
+      end
+
+      final_row_indexes = (start_index...end_index).to_a
+      final_row_indexes.fill(nil,final_row_indexes.size...columns)
+      indexes += final_row_indexes
+    end
+
+    return GridStruct::Selector.new(self, *indexes).dimensions(rows,columns)
+  end
+
+  def row(n)
+    start_index = (n * @columns)
+    end_index = start_index + @columns
+    GridStruct::Selector.new(self,*(start_index...end_index))
+  end
+
+  def column(n)
+    GridStruct::Selector.new(self,*@rows.times.map do |row|
+      get_index(row,n)
+    end)
+  end
+
+  def diagonals(row,column)
+    selectors = []
+
+    first = diagonal_builder({row: row, column: column})
+    second = diagonal_builder({row: row, column: column}, 1, -1)
+
+    selectors.push(GridStruct::Selector.new(self, *first)) if first.size > 1
+    selectors.push(GridStruct::Selector.new(self, *second)) if second.size > 1
+
+    return selectors
+  end
+
+  def size
+    @rows * @columns
+  end
+
+  def to_a
+    store_size = @store.size
+    return @store.dup.fill(nil,store_size...size)
+  end
+
+  def ==(other)
+    @store == other.instance_variable_get(:@store)
+  end
+
+  protected
+
+  def get_index(row,column)
+    (row * @columns) + column
+  end
+
+  def get_row_column_at(index)
+    row = index / @columns
+    column = index - (row * @columns)
+    return { row: row, column: column }
+  end
+
+  def diagonal_builder(coordinates, row_direction = 1, column_direction = 1, diagonal_indexes = [], action = :push)
+    row = coordinates[:row]
+    column = coordinates[:column]
+    index = get_index(row,column)
+
+    if !diagonal_indexes.include?(index) &&
+        row >= 0 &&
+        column >= 0 &&
+        row < @rows &&
+        column < @columns
+
+      diagonal_indexes.method(action).call(get_index(row,column))
+
+      diagonal_builder({ row: row - (row_direction * 1),
+                         column: column - (column_direction * 1) },
+                         row_direction,
+                         column_direction,
+                         diagonal_indexes,
+                         :unshift)
+
+      diagonal_builder({ row: row + (row_direction * 1),
+                         column: column + (column_direction * 1) },
+                         row_direction,
+                         column_direction,
+                         diagonal_indexes,
+                         :push)
+
+    end
+
+    return diagonal_indexes
+  end
+
+end

data/spec/lib/grid_struct/selector_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe ::GridStruct::Selector do
+
+  let(:grid) { GridStruct.new(9,9) }
+  let(:indexes) { [0,3,34,57] }
+  subject(:selector) { described_class.new(grid,*indexes)  }
+
+  before(:each) do
+    grid.map! do |value,row,column|
+      ((row * grid.columns) + column) * 2
+    end
+  end
+
+  it { is_expected.to have_attributes(grid: grid,
+                                      indexes: indexes) }
+
+  describe '#[]' do
+    it 'retrieve the x element in the current selection' do
+      expect(selector[0]).to eq 0
+      expect(selector[1]).to eq 6
+      expect(selector[2]).to eq 68
+      expect(selector[3]).to eq 114
+    end
+
+    context 'when mapped index is nil' do
+      let(:broken_selector) { described_class.new(grid, [0,nil,nil,nil]) }
+
+      it 'returns nil' do
+        expect(broken_selector[1]).to be_nil
+      end
+    end
+  end
+
+  describe '#[]=' do
+    it 'sets the value in the grid through the selector' do
+      selector[0] = -10
+      selector[1] = -3
+      selector[2] = 'hello world'
+      expect(grid.store[0]).to eq -10
+      expect(grid.store[3]).to eq -3
+      expect(grid.store[34]).to eq 'hello world'
+    end
+
+    context 'when mapped index is nil' do
+      let(:broken_selector) { described_class.new(grid, [0,nil,nil,nil]) }
+
+      it 'ignores action' do
+        store = grid.store
+        broken_selector[1] = 100
+        expect(grid.store).to eq store
+      end
+    end
+  end
+
+  describe '#dimensions' do
+    it 'sets the virtual dimensions of the current selection' do
+      selector.dimensions(2,3)
+      expect(selector.rows).to eq 2
+      expect(selector.columns).to eq 3
+    end
+  end
+
+  describe '#to_a' do
+    it 'fetches and returns selector values into an array' do
+      expect(selector.to_a).to eq [0,6,68,114]
+    end
+    it 'does not modify the grid when manipulating retuning array' do
+      array = selector.to_a
+      array[0] = -100
+      expect(grid.store[0]).not_to eq -100
+    end
+  end
+
+  describe 'to_grid' do
+    it 'converts current selection into a new grid, with the given dimensions' do
+      expect(selector.to_grid(2,2)).to eq GridStruct.new(2,2,[0,6,68,114])
+    end
+  end
+
+end

data/spec/lib/grid_struct_spec.rb

@@ -0,0 +1,296 @@
+require 'spec_helper'
+
+describe ::GridStruct do
+
+  let(:sudoku_grid) { GridStruct.new(9,9) }
+  before(:each) do
+    #  Fill grid as such
+    #
+    #  |----|----|----|----|----|----|----|----|----|
+    #  |  0 |  1 |  2 |  3 |  4 |  5 |  6 |  7 |  8 |
+    #  |----|----|----|----|----|----|----|----|----|
+    #  |  9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 |
+    #  |----|----|----|----|----|----|----|----|----|
+    #  | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 |
+    #  |----|----|----|----|----|----|----|----|----|
+    #  | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 |
+    #  |----|----|----|----|----|----|----|----|----|
+    #  | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 |
+    #  |----|----|----|----|----|----|----|----|----|
+    #  | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 |
+    #  |----|----|----|----|----|----|----|----|----|
+    #  | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 |
+    #  |----|----|----|----|----|----|----|----|----|
+    #  | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 |
+    #  |----|----|----|----|----|----|----|----|----|
+    #  | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 |
+    #  |----|----|----|----|----|----|----|----|----|
+
+    sudoku_grid.map! do |value, row, column|
+      row * sudoku_grid.columns + column
+    end
+  end
+
+  let(:rows) { 2 }
+  let(:columns) { 3 }
+  subject(:grid) { GridStruct.new(rows, columns) }
+
+  it { is_expected.to have_attributes(rows: rows,
+                                      columns: columns) }
+
+  describe '#size' do
+    it 'is the multiplication of with and height' do
+      expect(grid.size).to be rows * columns
+    end
+  end
+
+  describe '#set' do
+    it 'sets the value at the given row and column' do
+      grid.set(0,0) { 1 }
+      store = grid.instance_variable_get(:@store)
+      expect(store).to eq [1]
+
+      grid.set(1,0) { 2 }
+      store = grid.instance_variable_get(:@store)
+      expect(store).to eq [1,nil,nil,2]
+    end
+  end
+
+  describe '#each' do
+    before(:each) do
+      grid.instance_variable_set(:@store, [0,1,2,3,4,5])
+    end
+
+    it 'iterates through each elements of the grid (left to right, top to bottom)' do
+      values = []
+      grid.each do |element,row,column|
+        values[(row * grid.columns) + column] = element
+      end
+      expect(values.size).to be grid.size
+      expect(values).to eq grid.to_a
+    end
+  end
+
+  describe '#map!' do
+    it 'replaces all the elements in the grid' do
+      grid.map! do |value, row, column|
+        (row + 1) * (column + 1)
+      end
+      store = grid.instance_variable_get(:@store)
+      expect(store).to eq [1,2,3,2,4,6]
+    end
+  end
+
+  describe '#map_row!' do
+    it 'replaces the elements in the targeted row' do
+      grid.map_row!(0) { |value, column| column }
+      store = grid.instance_variable_get(:@store)
+      expect(store).to eq [0,1,2]
+
+      grid.map_row!(1) { |value, column| column**2 }
+      store = grid.instance_variable_get(:@store)
+      expect(store).to eq [0,1,2,0,1,4]
+    end
+  end
+
+  describe '#map_column!' do
+    it 'replaces the elements in the targeted column' do
+      grid.map_column!(0) { |value, row| row }
+      store = grid.instance_variable_get(:@store)
+      expect(store).to eq [0,nil,nil,1]
+
+      grid.map_column!(1) { |value, row| row + 1 }
+      store = grid.instance_variable_get(:@store)
+      expect(store).to eq [0,1,nil,1,2]
+    end
+  end
+
+  describe '#each_slice' do
+    it 'iterates through sub-grids of the given rows and columns' do
+      sub_grids = []
+      sudoku_grid.each_slice(3,3) do |sub_grid,index|
+        sub_grids[index] = sub_grid
+      end
+      expect(sub_grids[0].to_a).to eq [0,1,2,9,10,11,18,19,20]
+      expect(sub_grids[1].to_a).to eq [3,4,5,12,13,14,21,22,23]
+      expect(sub_grids[2].to_a).to eq [6,7,8,15,16,17,24,25,26]
+      expect(sub_grids[3].to_a).to eq [27,28,29,36,37,38,45,46,47]
+      expect(sub_grids[4].to_a).to eq [30,31,32,39,40,41,48,49,50]
+      expect(sub_grids[5].to_a).to eq [33,34,35,42,43,44,51,52,53]
+      expect(sub_grids[6].to_a).to eq [54,55,56,63,64,65,72,73,74]
+      expect(sub_grids[7].to_a).to eq [57,58,59,66,67,68,75,76,77]
+      expect(sub_grids[8].to_a).to eq [60,61,62,69,70,71,78,79,80]
+    end
+
+    context 'when slice is equal to the grid' do
+      it 'iterates a single time with a copy of the current grid' do
+        selector = nil
+        sudoku_grid.each_slice(9,9) do |sub_grid|
+          selector = sub_grid
+        end
+        expect(selector.to_grid).to eq sudoku_grid
+      end
+    end
+
+    context 'when slice is bigger than the grid' do
+      it 'iterates a single time with content of current grid with extra edges' do
+        selector = nil
+        sudoku_grid.each_slice(10,10) do |sub_grid|
+          selector = sub_grid
+        end
+        sudoku_grid.rows.times.each do |row_index|
+          expect(selector.to_grid.row(row_index).to_a).to eq (sudoku_grid.row(row_index).to_a + [nil])
+        end
+        sudoku_grid.columns.times.each do |column_index|
+          expect(selector.to_grid.column(column_index).to_a).to eq (sudoku_grid.column(column_index).to_a + [nil])
+        end
+      end
+    end
+
+    context 'when last slice bleeds out of the grid' do
+      it 'nullify the extras' do
+        sub_grids = []
+        sudoku_grid.each_slice(2,4) do |sub_grid,index|
+          sub_grids[index] = sub_grid
+        end
+        expect(sub_grids[2].to_a).to eq [8,nil,nil,nil,17,nil,nil,nil]
+        expect(sub_grids[5].to_a).to eq [26,nil,nil,nil,35,nil,nil,nil]
+        expect(sub_grids[8].to_a).to eq [44,nil,nil,nil,53,nil,nil,nil]
+        expect(sub_grids[11].to_a).to eq [62,nil,nil,nil,71,nil,nil,nil]
+        expect(sub_grids[12].to_a).to eq [72,73,74,75,nil,nil,nil,nil]
+        expect(sub_grids[13].to_a).to eq [76,77,78,79,nil,nil,nil,nil]
+        expect(sub_grids[14].to_a).to eq [80,nil,nil,nil,nil,nil,nil,nil]
+      end
+    end
+  end
+
+  describe '#get' do
+    context 'a non-set cell' do
+      it 'returns nil' do
+        expect(grid.get(0,0)).to be_nil
+      end
+    end
+    context 'an already set cell' do
+      before(:each) do
+        grid.instance_variable_set(:@store, [nil,8,nil,9,2,nil])
+      end
+
+      it 'returns the stored value at the given row and column' do
+        expect(grid.get(0,0)).to be_nil
+        expect(grid.get(0,1)).to be 8
+        expect(grid.get(0,2)).to be_nil
+        expect(grid.get(1,0)).to be 9
+        expect(grid.get(1,1)).to be 2
+        expect(grid.get(1,2)).to be_nil
+      end
+    end
+  end
+
+  describe '#row' do
+    before(:each) do
+      grid.instance_variable_set(:@store, [nil,8,nil,9,2,nil])
+    end
+
+    it 'returns a selector' do
+      expect(grid.row(0)).to be_kind_of(GridStruct::Selector)
+    end
+
+    it 'retrieves a selector of the requested row' do
+      expect(grid.row(0).to_a).to eq [nil,8,nil]
+      expect(grid.row(1).to_a).to eq [9,2,nil]
+    end
+  end
+
+  describe '#column' do
+    before(:each) do
+      grid.instance_variable_set(:@store, [nil,8,nil,9,2,nil])
+    end
+
+    it 'returns a selector' do
+      expect(grid.column(0)).to be_kind_of(GridStruct::Selector)
+    end
+
+    it 'retrieves a selector of the requested column' do
+      expect(grid.column(0).to_a).to eq [nil,9]
+      expect(grid.column(1).to_a).to eq [8,2]
+      expect(grid.column(2).to_a).to eq [nil,nil]
+    end
+  end
+
+  describe '#diagonals' do
+    it 'returns an array' do
+      expect(grid.diagonals(0,0)).to be_kind_of Array
+    end
+
+    context 'when fetching diagonals not from a corner' do
+      it 'returns 2 selectors' do
+        diagonals = sudoku_grid.diagonals(4,4)
+        expect(diagonals.size).to be 2
+        expect(diagonals.first).to be_kind_of(GridStruct::Selector)
+        expect(diagonals.last).to be_kind_of(GridStruct::Selector)
+      end
+
+      it 'returns the diagonals crossing the given coordinates' do
+        diagonals = sudoku_grid.diagonals(4,4)
+        expect(diagonals.first.to_a).to eq [0,10,20,30,40,50,60,70,80]
+        expect(diagonals.last.to_a).to eq [8,16,24,32,40,48,56,64,72]
+      end
+
+      context 'the returned selectors' do
+        it 'approprietly modify its matching element' do
+          diagonals = sudoku_grid.diagonals(4,4)
+          diagonals.first[4] = -100
+          expect(sudoku_grid.get(4,4))
+        end
+      end
+    end
+
+    context 'when fetching diagonals from a corner' do
+      it 'only returns 1 diagonal selector' do
+        expect(sudoku_grid.diagonals(0,0).size).to be 1
+        expect(sudoku_grid.diagonals(0,sudoku_grid.columns - 1).size).to be 1
+        expect(sudoku_grid.diagonals(sudoku_grid.rows - 1,0).size).to be 1
+        expect(sudoku_grid.diagonals(sudoku_grid.rows - 1, sudoku_grid.columns - 1).size).to be 1
+      end
+    end
+  end
+
+  describe '#slice' do
+    it 'returns a selector' do
+      expect(sudoku_grid.slice(0, rows: 3, columns: 3)).to be_kind_of(GridStruct::Selector)
+    end
+
+    context 'the returned selector' do
+      it 'modifies its matching element' do
+        slice = sudoku_grid.slice(0, rows: 3, columns: 3)
+        slice[4] = -100
+        expect(sudoku_grid.get(1,1)).to eq -100
+      end
+
+      context 'when slice goes out of bound' do
+        it 'adds extras when converting to grid' do
+          slice = sudoku_grid.slice(2, rows: 2, columns: 4)
+          expect(slice.to_grid.to_a).to eq [8,nil,nil,nil,17,nil,nil,nil]
+        end
+      end
+    end
+  end
+
+  describe '#to_a' do
+    it 'returns an array matching size of the grid' do
+      expect(grid.to_a.size).to be grid.size
+    end
+
+    it 'returns content of grid store' do
+      grid.instance_variable_set(:@store, [0,1,2,3,4,5])
+      expect(grid.to_a).to eq [0,1,2,3,4,5]
+    end
+
+    it 'returns a copy' do
+      grid.instance_variable_set(:@store, [0,1,2,3,4,5])
+      array = grid.to_a
+      array[0] = 100
+      expect(grid.get(0,0)).to be 0
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'grid_struct'
+
+RSpec.configure do |config|
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :should
+  end
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: grid_struct
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Samuel Molinari
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-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: 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'
+description: Grid data structure
+email:
+- samuel@molinari.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- grid_struct.gemspec
+- lib/grid_struct.rb
+- lib/grid_struct/selector.rb
+- lib/grid_struct/version.rb
+- spec/lib/grid_struct/selector_spec.rb
+- spec/lib/grid_struct_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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.6
+signing_key: 
+specification_version: 4
+summary: Handle a grid data structure
+test_files:
+- spec/lib/grid_struct/selector_spec.rb
+- spec/lib/grid_struct_spec.rb
+- spec/spec_helper.rb