letter_press_is_not_as_good_as_boggle 1.0.0

data/example.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift File.expand_path '../lib', __FILE__
+require 'letter_press_is_not_as_good_as_boggle'
+
+LetterPressIsNotAsGoodAsBoggle do
+  board %w[h z e o f
+           h p h y i
+           h w e b r
+           x z u g o
+           b i o g f]
+
+  guesses %w[groupie
+             hogger]
+
+  # get the list of all known words that can be made on the board
+  # unless hey have already been guessed
+  words.each { |word| puts word }
+end

data/letter_press_is_not_as_good_as_boggle.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "letter_press_is_not_as_good_as_boggle/version"
+
+Gem::Specification.new do |s|
+  s.name        = "letter_press_is_not_as_good_as_boggle"
+  s.version     = LetterPressIsNotAsGoodAsBoggle::VERSION
+  s.authors     = ["Josh Cheek"]
+  s.email       = ["josh.cheek@gmail.com"]
+  s.homepage    = "https://github.com/JoshCheek/letter_press_is_not_as_good_as_boggle"
+  s.summary     = %q{Find all known words for a letterpress board}
+  s.description = %q{Find all known words for a letterpress board (iPhone 5 game that is like boggle, but worse)}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec",                                "~> 2.4"
+  s.add_development_dependency "simplecov",                            "~> 0.7.1"
+end

data/lib/letter_press_is_not_as_good_as_boggle.rb

@@ -0,0 +1,58 @@
+require 'letter_press_is_not_as_good_as_boggle/board_traverser'
+require 'letter_press_is_not_as_good_as_boggle/word_list'
+require 'letter_press_is_not_as_good_as_boggle/word_list/searcher'
+require 'set'
+
+def LetterPressIsNotAsGoodAsBoggle(&block)
+  LetterPressIsNotAsGoodAsBoggle.new(&block).words
+end
+
+class LetterPressIsNotAsGoodAsBoggle
+  def self.all_words
+    words = File.readlines File.expand_path '../../data/word_list', __FILE__
+    words.map &:chomp!
+    words
+  end
+
+  def initialize(all_words=LetterPressIsNotAsGoodAsBoggle.all_words, &definition)
+    self.definition = definition
+    self.searcher = searcher_for all_words
+    instance_eval &definition
+  end
+
+  def searcher_for(all_words)
+    WordList::Searcher.new WordList.new all_words
+  end
+
+  def board(chars)
+    self.chars = chars
+  end
+
+  def guesses(guesses=nil)
+    guesses && (@guesses = guesses)
+    @guesses
+  end
+
+  def words
+    @words ||= begin
+      words = Set.new
+      board_traverser.each_with_recur do |word, char, recurser|
+        next unless searcher.down? char
+        searcher.down char
+        words << word if searcher.word? && !@guesses.include?(word)
+        recurser.call
+        searcher.up
+      end
+      words.sort_by { |word| word.length }
+    end
+  end
+
+  private
+
+  attr_accessor :chars, :searcher, :definition
+
+  def board_traverser
+    @board_traverser ||= BoardTraverser.new chars
+  end
+end
+

data/lib/letter_press_is_not_as_good_as_boggle/board_traverser.rb

@@ -0,0 +1,27 @@
+class LetterPressIsNotAsGoodAsBoggle
+  class BoardTraverser
+
+    attr_accessor :characters
+
+    def initialize(characters)
+      self.characters = characters
+    end
+
+    def each_with_recur(&block)
+      recursive_each_with_recur "", [], block
+    end
+
+    def recursive_each_with_recur(current, path, block)
+      characters.each do |char|
+        next if path.any? { |path_char| path_char.equal? char }
+        new_current = current + char
+        path.push char
+        recurser = lambda { recursive_each_with_recur new_current, path, block }
+        block.call new_current, char, recurser
+        path.pop
+      end
+    end
+
+  end
+end
+

data/lib/letter_press_is_not_as_good_as_boggle/version.rb

@@ -0,0 +1,3 @@
+class LetterPressIsNotAsGoodAsBoggle
+  VERSION = '1.0.0'
+end

data/lib/letter_press_is_not_as_good_as_boggle/word_list.rb

@@ -0,0 +1,21 @@
+require 'letter_press_is_not_as_good_as_boggle/word_list/node'
+
+class LetterPressIsNotAsGoodAsBoggle
+  class WordList
+    attr_reader :root
+
+    def initialize(all_words=[])
+      @root = Node.new ''
+      all_words.each { |word| self << word }
+    end
+
+    def <<(word)
+      root.add word.chars.to_a
+      self
+    end
+
+    def words
+      root.words
+    end
+  end
+end

data/lib/letter_press_is_not_as_good_as_boggle/word_list/node.rb

@@ -0,0 +1,59 @@
+class LetterPressIsNotAsGoodAsBoggle
+  class WordList
+    class Node
+      attr_reader :parent
+
+      def initialize(char, parent=nil)
+        @char, @parent, @children = char, parent, Hash.new
+      end
+
+      def add(chars)
+        if chars.empty?
+          is_word!
+          return
+        end
+        char = chars.shift
+        add_child char, chars
+      end
+
+      def child?(char)
+        @children.has_key? char
+      end
+
+      def child(char)
+        @children.fetch char
+      end
+
+      def word?
+        @is_word
+      end
+
+      def to_s
+        @parent.to_s << @char
+      end
+
+      def words
+        words = []
+        words << to_s if word?
+        @children.each { |char, child| words.concat child.words }
+        words
+      end
+
+      def inspect
+        "#<Dictionary::Node #{to_s}>"
+      end
+
+      private
+
+      def add_child(char, chars)
+        @children[char] ||= Node.new char, self
+        @children[char].add chars
+      end
+
+      def is_word!
+        @is_word = true
+      end
+    end
+  end
+end
+

data/lib/letter_press_is_not_as_good_as_boggle/word_list/searcher.rb

@@ -0,0 +1,37 @@
+class LetterPressIsNotAsGoodAsBoggle
+  class WordList
+    class Searcher
+      NoPath = Class.new StandardError
+
+      attr_reader :word_list
+
+      def initialize(word_list)
+        @node = word_list.root
+      end
+
+      def down?(char)
+        @node.child? char
+      end
+
+      def down(char)
+        raise NoPath, "No path #{@node.to_s << char}." unless down? char
+        @node = @node.child char
+      end
+
+      def current
+        @node.to_s
+      end
+
+      def up
+        new_node = @node.parent
+        raise NoPath, "Can't go up from root." unless new_node
+        @node = new_node
+      end
+
+      # rename to on_word?
+      def word?
+        @node.word?
+      end
+    end
+  end
+end

data/spec/acceptance_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe 'some acceptance specs' do
+  specify 'words are returned sorted by length asc and do not include duplicates or previous guesses' do
+    unguessed   = %w[ab abc dac]
+    guessed     = %w[adc dab]
+    nonmatching = %w[x nek]
+    all_words   = unguessed + guessed + nonmatching
+
+    letter_press = LetterPressIsNotAsGoodAsBoggle.new all_words do
+      board   %w[a b c d a]
+      guesses %w[adc dab]
+    end
+
+    letter_press.words.should == %w[ab abc dac]
+  end
+end

data/spec/board_traverer_spec.rb

@@ -0,0 +1,22 @@
+require 'letter_press_is_not_as_good_as_boggle'
+
+describe 'traversing the board' do
+  it 'traverses each possibility, yielding the current word, current char and a recur object' do
+    words = []
+    LetterPressIsNotAsGoodAsBoggle::BoardTraverser.new(%w[a b c]).each_with_recur do |word, char, recurser|
+      word.should end_with char
+      words << word
+      recurser.call
+    end
+    words.should =~ %w[a b c ab ac abc acb ba bc bac bca ca cb cab cba]
+  end
+
+  it "recurses when called, and doesn't when not called" do
+    words = []
+    LetterPressIsNotAsGoodAsBoggle::BoardTraverser.new(%w[a b c]).each_with_recur do |word, char, recurser|
+      words << word
+      recurser.call if word.end_with?("a")
+    end
+    words.should =~ %w[a b c ab ac]
+  end
+end

data/spec/searcher_spec.rb

@@ -0,0 +1,74 @@
+require 'letter_press_is_not_as_good_as_boggle/word_list/searcher'
+
+class LetterPressIsNotAsGoodAsBoggle
+  describe WordList::Searcher do
+    let(:word_list) { WordList.new }
+    let(:searcher)  { WordList::Searcher.new word_list }
+
+    before do
+      word_list << 'they'
+      word_list << 'then'
+    end
+
+    it 'can go down a char' do
+      searcher.down('t')
+      searcher.down('h')
+      searcher.current.should == 'th'
+    end
+
+    it 'can go back up a char' do
+      searcher.down('t')
+      searcher.down('h')
+      searcher.up
+      searcher.current.should == 't'
+    end
+
+    it "raises an error if told to go down to a char doesn't make a word" do
+      searcher.down 't'
+      expect { searcher.down('a') }.to raise_error WordList::Searcher::NoPath, /ta/
+    end
+
+    it 'raises an error if told to go up from the root' do
+      expect { searcher.up }.to raise_error WordList::Searcher::NoPath, /root/
+    end
+
+    it 'knows when it is on a word in the word list' do
+      searcher.should_not be_word
+      searcher.down('t')
+      searcher.should_not be_word
+      searcher.down('h')
+      searcher.should_not be_word
+      searcher.down('e')
+      searcher.should_not be_word
+      searcher.down('n')
+      searcher.should be_word
+    end
+
+    it 'knows what paths it can go down' do
+      searcher.should be_down 't'
+      searcher.should_not be_down 'a'
+    end
+
+    example 'acceptance' do
+      searcher.should_not be_word
+      searcher.down 't'
+      searcher.should_not be_word
+      searcher.down 'h'
+      searcher.should_not be_word
+      searcher.down 'e'
+      searcher.should_not be_word
+      searcher.down 'n'
+      searcher.should be_word
+      searcher.current.should == 'then'
+      searcher.up
+      searcher.down 'y'
+      searcher.should be_word
+      searcher.current.should == 'they'
+      searcher.up
+      searcher.up
+      searcher.up
+      searcher.up
+      expect { searcher.up }.to raise_error WordList::Searcher::NoPath
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'simplecov'
+SimpleCov.start
+require 'letter_press_is_not_as_good_as_boggle'

data/spec/word_list_spec.rb

@@ -0,0 +1,12 @@
+require 'letter_press_is_not_as_good_as_boggle/word_list'
+
+describe LetterPressIsNotAsGoodAsBoggle::WordList do
+  it 'knows all the words that were added to it' do
+    word_list = LetterPressIsNotAsGoodAsBoggle::WordList.new
+    word_list.words.should == []
+    word_list << "abc"
+    word_list << "abcd"
+    word_list << "ecx"
+    word_list.words.should == ["abc", "abcd", "ecx"]
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: letter_press_is_not_as_good_as_boggle
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Josh Cheek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70224887901560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: *70224887901560
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &70224887901060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: *70224887901060
+description: Find all known words for a letterpress board (iPhone 5 game that is like
+  boggle, but worse)
+email:
+- josh.cheek@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Readme.md
+- data/word_list
+- example.rb
+- letter_press_is_not_as_good_as_boggle.gemspec
+- lib/letter_press_is_not_as_good_as_boggle.rb
+- lib/letter_press_is_not_as_good_as_boggle/board_traverser.rb
+- lib/letter_press_is_not_as_good_as_boggle/version.rb
+- lib/letter_press_is_not_as_good_as_boggle/word_list.rb
+- lib/letter_press_is_not_as_good_as_boggle/word_list/node.rb
+- lib/letter_press_is_not_as_good_as_boggle/word_list/searcher.rb
+- spec/acceptance_spec.rb
+- spec/board_traverer_spec.rb
+- spec/searcher_spec.rb
+- spec/spec_helper.rb
+- spec/word_list_spec.rb
+homepage: https://github.com/JoshCheek/letter_press_is_not_as_good_as_boggle
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Find all known words for a letterpress board
+test_files:
+- spec/acceptance_spec.rb
+- spec/board_traverer_spec.rb
+- spec/searcher_spec.rb
+- spec/spec_helper.rb
+- spec/word_list_spec.rb