word_search 0.1.0

data/.ruby-version

@@ -0,0 +1 @@
+2.3.0

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.3.0
+script:
+  - rake

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 npezza93
+
+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,61 @@
+# ![Word Search](https://raw.githubusercontent.com/google/material-design-icons/master/action/drawable-xxxhdpi/ic_search_black_18dp.png)Word Search Generator and Solver
+
+[![Build Status](https://travis-ci.org/npezza93/word_search.svg?branch=master)](https://travis-ci.org/npezza93/word_search)
+[![Code Climate](https://codeclimate.com/github/npezza93/word_search/badges/gpa.svg)](https://codeclimate.com/github/npezza93/word_search)
+[![Test Coverage](https://codeclimate.com/github/npezza93/word_search/badges/coverage.svg)](https://codeclimate.com/github/npezza93/word_search/coverage)
+
+## Install
+Add WordSearch to your `Gemfile` and `bundle install`:
+
+`gem 'word_search'`
+
+Alternatively, you can install the gem from [rubygems.org](https://rubygems.org/):
+
+`gem install word_search`
+
+## Usage
+
+To create a plane with just random letters in each position:
+
+```ruby
+❯ plane = WordSearch::Plane.new(5, 5)
+❯ plane.add_letters
+# To traverse the cartesian plane:
+❯ plane[0][3]
+=> #<WordSearch::TwoDimensional::Point:0x007facf1d8d7e0 @letter="u", @x=0, @y=3>
+❯ plane.pto_s
+nvqgy
+uhsit
+zqloh
+muudd
+himyj
+
+# To print to a file(without a filename defaults to 'crossword')
+❯ plane.print(file_name)
+
+# When printing a 3D crossword there are two spaces between z slices. The top slice is z = 0.
+❯ plane = WordSearch::Plane.new(3, 3, 2)
+❯ plane.add_letters
+❯ plane.pto_s
+bxv
+lud
+agp
+
+esj
+era
+utg
+```
+
+To create plane filled with words supplied by a word bank:
+```ruby
+❯ generator = WordSearch::Generator.new('words.csv', 5, 5) # or add a z param to get a 3D word search
+❯ generator.perform
+❯ generator.word_bank
+=> ["word", "hello", "bye"]
+❯ generator.pto_s
+ghsii
+eelwt
+ylcon
+blarz
+yoydt
+```

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+task :console do
+  require 'pry'
+  require 'word_searcher'
+  ARGV.clear
+  Pry.start
+end
+
+RuboCop::RakeTask.new
+RSpec::Core::RakeTask.new(:spec)
+task default: [:spec, :rubocop]

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'word_search'
+require 'pry'
+require 'benchmark'
+
+Pry.start

data/bin/coverage

@@ -0,0 +1 @@
+open coverage/index.html

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/lib/word_search/generator/base.rb

@@ -0,0 +1,28 @@
+module WordSearch
+  class Generator
+    class Base
+      include ActiveModel::Validations
+
+      attr_accessor :plane, :word_bank, :used_coordinates
+      delegate :to_s, :pto_s, :print, to: :plane
+
+      def initialize(plane, word_bank)
+        @plane = plane
+        @word_bank = word_bank
+        @used_coordinates = []
+      end
+
+      def perform
+        word_bank.each do |word|
+          place_word(word)
+        end
+      end
+
+      private
+
+      def random(number)
+        SecureRandom.random_number number
+      end
+    end
+  end
+end

data/lib/word_search/generator.rb

@@ -0,0 +1,60 @@
+module WordSearch
+  class Generator < SimpleDelegator
+    include ActiveModel::Validations
+
+    validate :can_words_fit?
+    validate :valid_plane?
+    validate :valid_word_bank?
+
+    def initialize(file, x, y, z = nil)
+      plane = Plane.new(x, y, z)
+      obj =
+        if z.present?
+          ThreeDimensional::Generator.new(plane, WordBank.new(file))
+        else
+          TwoDimensional::Generator.new(plane, WordBank.new(file))
+        end
+
+      super obj
+    end
+
+    def perform
+      super
+
+      if valid?
+        plane.add_letters
+        plane
+      else
+        false
+      end
+    end
+
+    def object
+      __getobj__
+    end
+
+    private
+
+    def can_words_fit?
+      errors.add(:base, words_too_long) if plane.max < word_bank.longest_length
+    end
+
+    def words_too_long
+      "#{word_bank.longest_words.join(' and ')} "\
+      "#{'is'.pluralize(word_bank.longest_words.count)} "\
+      'too long for the word search'
+    end
+
+    def valid_plane?
+      plane.errors.full_messages.each do |msg|
+        errors.add(:base, msg)
+      end unless plane.valid?
+    end
+
+    def valid_word_bank?
+      word_bank.errors.full_messages.each do |msg|
+        errors.add(:base, msg)
+      end unless word_bank.valid?
+    end
+  end
+end

data/lib/word_search/plane/base.rb

@@ -0,0 +1,52 @@
+module WordSearch
+  class Plane
+    class Base < Hash
+      include ActiveModel::Validations
+
+      attr_accessor :x, :y
+
+      validates :x, :y, numericality: { greater_than_or_equal_to: 2 }
+
+      def print(file_name = nil)
+        file = File.open(file_name || 'crossword', 'w')
+        file.write(to_s)
+        file
+      end
+
+      def random_letter
+        ('a'..'z').to_a[SecureRandom.random_number(26)]
+      end
+
+      def two_dimensional?
+        true
+      end
+
+      def three_dimensional?
+        false
+      end
+
+      def add_letters
+        x.times do |x_point|
+          y.times do |y_point|
+            yield(x_point, y_point)
+          end
+        end
+      end
+
+      def pto_s
+        puts to_s
+      end
+
+      private
+
+      def initialize_plane
+        x.times do |x_point|
+          self[x_point] = {}
+          y.times do |y_point|
+            yield(x_point, y_point)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/word_search/plane.rb

@@ -0,0 +1,22 @@
+module WordSearch
+  class Plane < SimpleDelegator
+    def initialize(x, y, z = nil)
+      obj =
+        if z.present? && z > 1
+          ThreeDimensional::Plane.new(x, y, z)
+        else
+          TwoDimensional::Plane.new(x, y)
+        end
+
+      super obj
+    end
+
+    def to_s
+      if invalid?
+        errors.full_messages.join("\n")
+      else
+        super
+      end
+    end
+  end
+end

data/lib/word_search/position_word/base.rb

@@ -0,0 +1,98 @@
+module WordSearch
+  class PositionWord
+    class Base
+      attr_accessor :plane, :word, :direction, :coordinate
+
+      def initialize(plane, word, direction, coordinate)
+        @plane = plane
+        @word = word
+        @direction = direction
+        @coordinate = coordinate
+      end
+
+      def perform
+        return false unless valid?
+
+        word.split('').each do |letter|
+          place_letter(letter)
+          update_coordinates
+        end
+      end
+
+      def valid?
+        valid_coordinates? && valid_letters?
+      end
+
+      private
+
+      def last_x
+        return @last_x if defined? @last_x
+
+        @last_x = coordinate.x
+        (word.length - 1).times do
+          @last_x += direction.x
+        end
+
+        @last_x
+      end
+
+      def last_y
+        return @last_y if defined? @last_y
+
+        @last_y = coordinate.y
+        (word.length - 1).times do
+          @last_y += direction.y
+        end
+
+        @last_y
+      end
+
+      def last_z
+        return @last_z if defined? @last_z
+
+        @last_z = coordinate.z
+        (word.length - 1).times do
+          @last_z += direction.z
+        end
+
+        @last_z
+      end
+
+      def valid_coordinates?
+        positive_last_coordinates? && last_coordinates_in_plane?
+      end
+
+      def valid_letters?
+        bad_overlap, intersection_points = false, 0
+
+        letters.count.times do |position|
+          next if letter_at(position).blank?
+
+          if letters[position] == letter_at(position)
+            intersection_points += 1
+          else
+            bad_overlap = true
+          end
+        end
+
+        !bad_overlap && intersection_points < 2
+      end
+
+      def letters
+        @letters ||= word.split('')
+      end
+
+      def x_at(position)
+        coordinate.x + position * direction.x
+      end
+
+      def y_at(position)
+        coordinate.y + position * direction.y
+      end
+
+      def z_at(position)
+        coordinate.z + position * direction.z
+      end
+    end
+  end
+end

data/lib/word_search/solver.rb

@@ -0,0 +1,15 @@
+module WordSearch
+  class Solver
+    attr_accessor :script, :word_bank, :plane
+
+    def initialize(script, word_list_file, plane_file)
+      @script = script
+      @word_bank = WordBank.new(word_list_file)
+      @plane = TwoDimensional::Plane.make_from_file(plane_file)
+    end
+
+    def execute
+      load(script, true)
+    end
+  end
+end

data/lib/word_search/three_dimensional/direction.rb

@@ -0,0 +1,37 @@
+module WordSearch
+  module ThreeDimensional
+    class Direction
+      include Ruby::Enum
+
+      # Standard cardinal directions
+      define :N,  [0,   1, 0]
+      define :NE, [1,   1, 0]
+      define :E,  [1,   0, 0]
+      define :SE, [1,  -1, 0]
+      define :S,  [0,  -1, 0]
+      define :SW, [-1, -1, 0]
+      define :W,  [-1,  0, 0]
+      define :NW, [-1,  1, 0]
+
+      # cardinal directions with a positive z index (forward)
+      define :NF,   [0,   1, 1]
+      define :NEF,  [1,   1, 1]
+      define :EF,   [1,   0, 1]
+      define :SEF,  [1,  -1, 1]
+      define :SF,   [0,  -1, 1]
+      define :SWF,  [-1, -1, 1]
+      define :WF,   [-1,  0, 1]
+      define :NWF,  [-1,  1, 1]
+
+      # cardinal directions with a negative z index (back)
+      define :NB,   [0,   1, -1]
+      define :NEB,  [1,   1, -1]
+      define :EB,   [1,   0, -1]
+      define :SEB,  [1,  -1, -1]
+      define :SB,   [0,  -1, -1]
+      define :SWB,  [-1, -1, -1]
+      define :WB,   [-1,  0, -1]
+      define :NWB,  [-1,  1, -1]
+    end
+  end
+end

data/lib/word_search/three_dimensional/generator.rb

@@ -0,0 +1,35 @@
+module WordSearch
+  module ThreeDimensional
+    class Generator < Generator::Base
+      def directions
+        Direction.values.shuffle.map do |direction|
+          Point.new(direction.first, direction.second, direction.third)
+        end
+      end
+
+      private
+
+      def place_word(word)
+        placed = false
+        until placed || used_coordinates.uniq.count == plane.total_points
+          placed = position_word(word).present?
+        end
+
+        word_bank.errors.add(word, 'cannot be placed') if placed.blank?
+        placed
+      end
+
+      def position_word(word)
+        used_coordinates << (coordinate = random_point)
+
+        directions.find do |direction|
+          PositionWord.new(plane, word, direction, coordinate).perform
+        end
+      end
+
+      def random_point
+        Point.new(random(plane.x), random(plane.y), random(plane.z))
+      end
+    end
+  end
+end

data/lib/word_search/three_dimensional/plane.rb

@@ -0,0 +1,89 @@
+module WordSearch
+  module ThreeDimensional
+    class Plane < Plane::Base
+      attr_accessor :z
+      validates :z, numericality: { greater_than_or_equal_to: 1 }
+
+      def initialize(x, y, z)
+        @x, @y, @z = x, y, z
+
+        initialize_plane do |x_point, y_point|
+          self[x_point][y_point] = {}
+          z.times do |z_point|
+            self[x_point][y_point][z_point] =
+              Point.new(x_point, y_point, z_point)
+          end
+        end
+      end
+
+      def to_s
+        (0..(z - 1)).map do |z_slice|
+          values.map do |row|
+            row.values.map { |ys| ys[z_slice] }.map(&:to_s)
+          end.transpose.reverse.map(&:join).join("\n")
+        end.join("\n\n")
+      end
+
+      def two_dimensional?
+        false
+      end
+
+      def three_dimensional?
+        true
+      end
+
+      def total_points
+        x * y * z
+      end
+
+      def max
+        [x, y, z].max
+      end
+
+      def add_letters
+        super do |x_point, y_point|
+          z.times do |z_point|
+            self[x_point][y_point][z_point].letter ||= random_letter
+          end
+        end
+      end
+
+      class << self
+        def make_from_file(file)
+          string = File.read(file).split("\n\n").map(&:split)
+
+          return false unless valid_file?(string)
+
+          make_word_search(string)
+        end
+
+        private
+
+        def valid_file?(string)
+          string.collect(&:length).uniq.count == 1 &&
+            string.flat_map { |row| row.map(&:length) }.uniq.count == 1
+        end
+
+        def make_word_search(string)
+          plane = empty_3d_plane_from_string(string)
+
+          string.each_with_index do |slice, z|
+            slice.reverse.each_with_index do |row, y|
+              row.split('').each_with_index do |letter, x|
+                plane[x][y][z] = Point.new(x, y, z, letter)
+              end
+            end
+          end
+
+          plane
+        end
+
+        def empty_3d_plane_from_string(string)
+          x = string.flat_map { |row| row.map(&:length) }.uniq.first
+          y = string.collect(&:length).uniq.first
+          new(x, y, string.count)
+        end
+      end
+    end
+  end
+end

data/lib/word_search/three_dimensional/point.rb

@@ -0,0 +1,15 @@
+module WordSearch
+  module ThreeDimensional
+    class Point
+      attr_accessor :x, :y, :z, :letter
+      alias to_s letter
+
+      def initialize(x, y, z, letter = nil)
+        @x = x
+        @y = y
+        @z = z
+        @letter = letter if letter
+      end
+    end
+  end
+end

data/lib/word_search/three_dimensional/position_word.rb

@@ -0,0 +1,29 @@
+module WordSearch
+  module ThreeDimensional
+    class PositionWord < PositionWord::Base
+      private
+
+      def place_letter(letter)
+        plane[coordinate.x][coordinate.y][coordinate.z].letter = letter
+      end
+
+      def update_coordinates
+        coordinate.x += direction.x
+        coordinate.y += direction.y
+        coordinate.z += direction.z
+      end
+
+      def positive_last_coordinates?
+        last_x >= 0 && last_y >= 0 && last_z >= 0
+      end
+
+      def last_coordinates_in_plane?
+        last_x < plane.x && last_y < plane.y && last_z < plane.z
+      end
+
+      def letter_at(position)
+        plane.dig(x_at(position), y_at(position), z_at(position)).letter
+      end
+    end
+  end
+end

data/lib/word_search/two_dimensional/direction.rb

@@ -0,0 +1,17 @@
+module WordSearch
+  module TwoDimensional
+    class Direction
+      include Ruby::Enum
+
+      # Standard cardinal directions
+      define :N,  [0,   1]
+      define :NE, [1,   1]
+      define :E,  [1,   0]
+      define :SE, [1,  -1]
+      define :S,  [0,  -1]
+      define :SW, [-1, -1]
+      define :W,  [-1,  0]
+      define :NW, [-1,  1]
+    end
+  end
+end

data/lib/word_search/two_dimensional/generator.rb

@@ -0,0 +1,35 @@
+module WordSearch
+  module TwoDimensional
+    class Generator < Generator::Base
+      def directions
+        Direction.values.shuffle.map do |direction|
+          Point.new(direction.first, direction.second)
+        end
+      end
+
+      private
+
+      def place_word(word)
+        placed = false
+        until placed || used_coordinates.uniq.count == plane.total_points
+          placed = position_word(word).present?
+        end
+
+        word_bank.errors.add(word, 'cannot be placed') if placed.blank?
+        placed
+      end
+
+      def position_word(word)
+        used_coordinates << (coordinate = random_point)
+
+        directions.find do |direction|
+          PositionWord.new(plane, word, direction, coordinate).perform
+        end
+      end
+
+      def random_point
+        Point.new(random(plane.x), random(plane.y))
+      end
+    end
+  end
+end