words_matrix 0.0.1

data/lib/words_matrix.rb

@@ -0,0 +1,8 @@
+module WordsMatrix
+  VERSION = "0.0.1"
+end
+
+require 'words_matrix/config'
+require 'words_matrix/matrix'
+require 'words_matrix/dictionary'
+require 'words_matrix/service'

data/lib/words_matrix/config.rb

@@ -0,0 +1,7 @@
+module WordsMatrix::Config
+  DEFAULTS = {
+    n: 10,
+    min_length: 3,
+    dict_path: "#{File.dirname(__FILE__)}/../../data/dict.txt"
+  }
+end

data/lib/words_matrix/dictionary.rb

@@ -0,0 +1,29 @@
+class WordsMatrix::Dictionary
+  attr_reader :words
+
+  def initialize(min_length, max_length, dict_path)
+    @dict_path = dict_path
+    @words = read_content(min_length, max_length)
+  end
+
+  private
+  def read_content(min_length, max_length)
+    contents = File.read(@dict_path).split("\n")
+
+    result = {}
+
+    contents.each do |word_line|
+      word = word_line[/^\S+/].to_s.upcase
+
+      break if word.length > max_length
+      if word.length >= min_length
+        result[word[0]] ||= {}
+        result[word[0]][word] = word_line
+      end
+    end
+
+    result
+  rescue SystemCallError => e
+    raise IOError, "error while reading dictionary file: #{e.message}"
+  end
+end

data/lib/words_matrix/matrix.rb

@@ -0,0 +1,82 @@
+class WordsMatrix::Matrix
+  attr_reader :grid, :tokens
+
+  def initialize(n, min_length)
+    @n = n
+    @min_length = min_length
+    @grid = generate_grid
+    parse_to_tokens!
+  end
+
+  def to_s
+    grid.map do |line|
+      line.join(" ")
+    end.join("\n")
+  end
+
+  def words_from(x, y)
+    raise ArgumentError, "Incorrect range" unless (0..@n-1).include?(x) || (0..@n-1).include?(y)
+    [
+      horizontal_line((y...@n).to_a, x),
+      horizontal_line((0..y).to_a.reverse, x),
+      vertical_line((x...@n).to_a, y),
+      vertical_line((0..x).to_a.reverse, y),
+      diagonal((x...@n).to_a, y),
+      diagonal((0..x).to_a.reverse, y),
+      diagonal((x...@n).to_a, y, -1),
+      diagonal((0..x).to_a.reverse, y, -1)
+    ].flatten.compact
+  end
+
+  private
+  def generate_grid
+    vowels = %w[A E O U I]
+    consonants = ('B'..'Z').to_a - vowels
+
+    Array.new(@n) do
+      Array.new(@n) do
+       (rand(4).zero? ? consonants : vowels).sample
+     end
+   end
+  end
+
+  def parse_to_tokens!
+    @tokens = Hash.new([])
+
+    (0...@n).each do |x|
+      (0...@n).each do |y|
+        words = words_from(x, y)
+        @tokens[@grid[x][y]] += words if words.any?
+      end
+    end
+  end
+
+  def horizontal_line(y_range, x)
+    return nil if invalid_range?(y_range)
+
+    y_range.to_a.map do |yt|
+      @grid[x][yt]
+    end.join
+  end
+
+  def vertical_line(x_range, y)
+    return nil if invalid_range?(x_range)
+
+    x_range.to_a.map do |xt|
+      @grid[xt][y]
+    end.join
+  end
+
+  def diagonal(x_range, y, multiplier=1)
+    return nil if invalid_range?(x_range) || !(0...@n).include?(y + multiplier*@min_length)
+
+    x_range.to_a.map.with_index do |xt, i|
+      next unless (0...@n).include? y+i*multiplier
+      @grid[xt][y+i*multiplier]
+    end.join
+  end
+
+  def invalid_range?(range)
+    range.size < @min_length
+  end
+end

data/lib/words_matrix/service.rb

@@ -0,0 +1,45 @@
+class WordsMatrix::Service
+  attr_reader :matrix, :dictionary, :words
+
+  def initialize(config={})
+    config = WordsMatrix::Config::DEFAULTS.merge(config) { |key, default, local|
+      local || default
+    }
+
+    validate_options!(config)
+    @matrix = WordsMatrix::Matrix.new(config[:n].to_i, config[:min_length].to_i)
+    @dictionary = WordsMatrix::Dictionary.new(config[:min_length].to_i, config[:n].to_i, config[:dict_path])
+
+    @words = []
+  end
+
+  def find_words
+    @matrix.tokens.each_pair do |letter, tokens|
+      next unless @dictionary.words.has_key?(letter)
+      words = @dictionary.words[letter].keys
+
+      tokens.each do |token|
+        words_found = words.select { |word| token =~ /^#{word}.*/ }
+
+        @words += words_found.map { |word| @dictionary.words[letter][word] }
+      end
+    end
+    @words.uniq!
+  end
+
+  def to_s
+    words_found = @words.any? ? @words.join("\n") : "none :("
+    ["Matrix:",
+      matrix.to_s,
+      "",
+      "Words found:",
+      words_found].join("\n")
+  end
+
+  private
+  def validate_options!(config)
+    raise ArgumentError, "matrix size should be a positive integer" if config[:n].to_i < 1
+    raise ArgumentError, "min word length should be a positive integer and less than matrix size" unless (0..config[:n].to_i).include?(config[:min_length].to_i)
+    raise ArgumentError, "dictionary path is not a valid file path" unless File.readable?(config[:dict_path])
+  end
+end

data/spec/fixtures/test_dict.txt

@@ -0,0 +1,13 @@
+
+AA rough, cindery lava [n -S]
+JAZZ to {enliven=v} [v -ED, -ING, -ES]
+ALBUM a book for preserving photographs or stamps [n -S]
+PHYLLOME a leaf of a plant [n -S]
+PHYSICAL a medical examination of the body [n -S]
+PHYSIQUE the form or structure of the body [n -S]
+PHYTANES <phytane=n> [n]
+PHYTONIC <phyton=n> [adj]
+WITHDRAWNNESSES <withdrawnness=n> [n]
+WOEBEGONENESSES <woebegoneness=n> [n]
+WONDERFULNESSES <wonderfulness=n> [n]
+WORRISOMENESSES <worrisomeness=n> [n]

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require "words_matrix"
+require "rspec/its"
+
+RSpec.configure do |config|
+  config.color = true
+  config.formatter = :documentation
+end

data/spec/words_matrix/dictionary_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe WordsMatrix::Dictionary do
+  let(:dict_path) {'spec/fixtures/test_dict.txt'}
+  let(:subject) {WordsMatrix::Dictionary.new(6, 9, dict_path)}
+
+  describe "#initialize" do
+    its(:words) { should_not be_nil }
+
+    it "should save only words of required length" do
+      expect(subject.words.keys).to eq ["P"]
+    end
+
+    context "file unreadable" do
+      it "should raise an error" do
+        expect{ WordsMatrix::Dictionary.new(15, 15, "inexisting path")}.to raise_error(IOError, /error while reading dictionary file: No such file or directory/)
+      end
+    end
+  end
+end

data/spec/words_matrix/matrix_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe WordsMatrix::Matrix do
+  let(:matrix) {WordsMatrix::Matrix.new(6, 4)}
+  let(:sample_grid) {
+    [
+      %w[A B C D E X],
+      %w[F G H I J X],
+      %w[K L M N O X],
+      %w[P Q R S T X],
+      %w[U V W X Y X],
+      %w[A B C D E X]
+    ]
+  }
+
+  describe "#initialize" do
+    it "should initialize grid" do
+      expect(matrix.grid).not_to be_nil
+    end
+
+    it "should parse grid to tokens" do
+      expect(matrix.tokens).not_to be_empty
+    end
+  end
+
+  describe "#grid" do
+    subject(:grid) { matrix.grid }
+
+    its(:size) { should eq 6 }
+    it "should have approximately 3 times more vowels" do
+      consonants_count = subject.flatten.count {|letter| !%w[A E I O U].include?(letter)}
+
+      expect(consonants_count).to be_within(10).of(subject.size**2 / 4)
+    end
+  end
+
+  describe "#tokens" do
+    before { allow_any_instance_of(WordsMatrix::Matrix).to receive(:generate_grid).and_return([["A", "B", "C"],["D", "E", "F"], ["G", "H", "I"]]) }
+    let(:matrix) { WordsMatrix::Matrix.new(3, 3) }
+
+    it "should exclude too short tokens" do
+      expect(matrix.tokens.keys).not_to include("E")
+    end
+  end
+
+  describe "#words_from" do
+    it "should skip all combinations shorter than min_length" do
+      expect(matrix.words_from(1, 0).any?{ |el| el.size < 4 }).to be false
+    end
+
+    context "letter check" do
+      before do
+        allow_any_instance_of(WordsMatrix::Matrix).to receive(:generate_grid).and_return(sample_grid)
+      end
+
+      it "should fetch appropriate horizontal letter combinations" do
+        expect(matrix.words_from(1,4)).to include("JIHGF")
+      end
+
+      it "should fetch appropriate vertical letter combinations" do
+        expect(matrix.words_from(1,4)).to include("JOTYE")
+      end
+
+      it "should fetch appropriate diagonal letter combinations" do
+        expect(matrix.words_from(1,4)).to include("JNRVA")
+      end
+
+      it "should not contain any additional letter combinations" do
+        expect(matrix.words_from(1,4).size).to eq 3
+      end
+    end
+  end
+end

data/spec/words_matrix/service_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe WordsMatrix::Service do
+  describe "#initialize" do
+    context "no local options given" do
+      let(:service) { WordsMatrix::Service.new }
+
+      it "should use default options" do
+        expect(service.matrix.grid.size).to eq WordsMatrix::Config::DEFAULTS[:n]
+        expect(service.matrix.instance_variable_get(:"@min_length")).to eq WordsMatrix::Config::DEFAULTS[:min_length]
+        expect(service.dictionary.instance_variable_get(:"@dict_path")).to eq WordsMatrix::Config::DEFAULTS[:dict_path]
+      end
+    end
+
+    context "local options given" do
+      let(:local_options) { {n: 5, dict_path: 'spec/fixtures/test_dict.txt', min_length: 4} }
+      it "should use local options with higher priority" do
+        service = WordsMatrix::Service.new(local_options)
+
+        expect(service.matrix.grid.size).to eq local_options[:n]
+        expect(service.matrix.instance_variable_get(:"@min_length")).to eq local_options[:min_length]
+        expect(service.dictionary.instance_variable_get(:"@dict_path")).to eq local_options[:dict_path]
+      end
+
+      context "invalid options" do
+        it "should validate the matrix size" do
+          local_options[:n] = double("something weird", to_i: 0)
+          expect{ WordsMatrix::Service.new(local_options) }.to raise_error(ArgumentError, "matrix size should be a positive integer")
+        end
+
+        it "should validate the min word size" do
+          local_options[:min_length] = 35
+          expect{ WordsMatrix::Service.new(local_options) }.to raise_error(ArgumentError, "min word length should be a positive integer and less than matrix size")
+        end
+
+        it "should check if dictionary file exists" do
+          local_options[:dict_path] = 'no file here'
+          expect{ WordsMatrix::Service.new(local_options) }.to raise_error(ArgumentError, "dictionary path is not a valid file path")
+        end
+      end
+    end
+  end
+
+  describe "#find_words" do
+    let(:sample_grid) {
+      [
+        %w[A B C D E X],
+        %w[F B L I M P],
+        %w[K L M N O S],
+        %w[P Q R S T X],
+        %w[U V W A Y X],
+        %w[A B C D E X]
+      ]
+    }
+    let(:service) { WordsMatrix::Service.new(n: 6, min_length: 4) }
+
+    before { allow_any_instance_of(WordsMatrix::Matrix).to receive(:generate_grid).and_return(sample_grid) }
+
+    it "should find all words not shorter than 4 chars" do
+      expected_result = [
+        "BLIMP a nonrigid aircraft [n -S] : BLIMPISH [adj]",
+        "DINS <din=v> [v]",
+        "EARL a British nobleman [n -S]",
+        "LIMP lacking rigidity [adj LIMPER, LIMPEST] / to walk lamely [v -ED, -ING, -S]",
+        "TOME a large book [n -S]"]
+      service.find_words
+
+      expect(service.words).to eq(expected_result)
+    end
+  end
+
+  describe "#to_s" do
+    let(:service) { WordsMatrix::Service.new(n: 6, min_length: 4, dict_path: 'spec/fixtures/test_dict.txt') }
+
+    before { service.find_words }
+
+    it "should print the matrix content" do
+      expect( service.to_s ).to include(service.matrix.to_s)
+    end
+
+    it "should print the words found" do
+      expect(service.to_s).to include(service.words.join("\n"))
+    end
+
+    context "no words found" do
+      it "should print a related message" do
+        allow(service).to receive(:words).and_return([])
+
+        expect(service.to_s).to include("Words found:\nnone :(")
+      end
+    end
+  end
+end

data/words_matrix.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'words_matrix'
+
+Gem::Specification.new do |spec|
+  spec.name          = "words_matrix"
+  spec.version       = WordsMatrix::VERSION
+  spec.authors       = ["Alona Mekhovova"]
+  spec.email         = ["alona.tarasova@gmail.com"]
+  spec.summary       = "Words search in a random letter matrix"
+  spec.description   = %q{
+    A command line app able to generate a random word search grid n x n (n: number of rows/number of columns) and find all the words inside it.
+
+    - The grid letters must be uppercase.
+    - The valid words are defined inside the file dict.txt
+    - The minimum size of a valid word is 3 characters.
+    - The program must detect all possible directions: horizontal, vertical and diagonal.
+
+    (The words can be on reverse order)
+  }
+  spec.homepage      = "https://github.com/alony/words_matrix"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = ["words_matrix"]
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib", "data"]
+
+  spec.add_runtime_dependency "thor"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec-its"
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: words_matrix
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alona Mekhovova
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-06 00:00:00.000000000 Z
+dependencies:
+- !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'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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: rspec-its
+  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: "\n    A command line app able to generate a random word search grid
+  n x n (n: number of rows/number of columns) and find all the words inside it.\n\n
+  \   - The grid letters must be uppercase.\n    - The valid words are defined inside
+  the file dict.txt\n    - The minimum size of a valid word is 3 characters.\n    -
+  The program must detect all possible directions: horizontal, vertical and diagonal.\n\n
+  \   (The words can be on reverse order)\n  "
+email:
+- alona.tarasova@gmail.com
+executables:
+- words_matrix
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/words_matrix
+- data/dict.txt
+- lib/words_matrix.rb
+- lib/words_matrix/config.rb
+- lib/words_matrix/dictionary.rb
+- lib/words_matrix/matrix.rb
+- lib/words_matrix/service.rb
+- spec/fixtures/test_dict.txt
+- spec/spec_helper.rb
+- spec/words_matrix/dictionary_spec.rb
+- spec/words_matrix/matrix_spec.rb
+- spec/words_matrix/service_spec.rb
+- words_matrix.gemspec
+homepage: https://github.com/alony/words_matrix
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- data
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Words search in a random letter matrix
+test_files:
+- spec/fixtures/test_dict.txt
+- spec/spec_helper.rb
+- spec/words_matrix/dictionary_spec.rb
+- spec/words_matrix/matrix_spec.rb
+- spec/words_matrix/service_spec.rb