scrabbler 0.1.2 → 0.1.3

data/README

@@ -6,7 +6,16 @@ Solve scrabble puzzles by the means of dictionary lookups.
 :en - English/US dictonary based as provided in Firefox
 
 == CLI
-A commandline tool is provided 
+A commandline tool is provided, use like this:
+
+scrabble [options] 'letters'
+    -l en                            Set language [en, nl]
+    -m max                           Limit the number of results
+    -t thresh                        Set the score threshold for the results
+    -e                               Show the score explanation
+    -h                               Show help
+
+it is possible to give multiple sets of letters.
 
 == Author
 Peter Maas (pfmmaas [at] gmail [dot] com)

data/bin/scrabblit

@@ -1,10 +1,12 @@
 require 'optparse'
+
 require File.dirname(__FILE__) + '/../lib/scrabbler.rb'
+include SCRABBLR
 
 options = {:language => :en, :max => 10, :thresh => 10, :explanation => false}
 
 optionParser = OptionParser.new do |opts|
-  opts.banner = "Usage: scrabblit [options, -h for help] 'letters'"
+  opts.banner = "Usage: scrabblit [options] 'letters'"
 
   opts.on("-l en", "Set language [en, nl]") do |l|
     options[:language] = l.to_sym
@@ -23,19 +25,20 @@ optionParser = OptionParser.new do |opts|
     puts opts
 	exit
   end
-end.parse!
 
-if ARGV && ARGV.length > 0
-  s = Scrabbler.new(options[:language])
-  ARGV.each do |set|
-    r = s.scrabble(set, options[:thresh], options[:language])
-	puts '==> ' + set
-    r[0...options[:max]].each do |score|
-      puts "#{score.word} (#{score.score})" 
-      puts "-- #{score.explanation.join(", ")}" if options[:explanation]
-    end
-    puts ''
+  if !ARGV || ARGV.length <= 0
+  	puts opts
+	exit
   end
-else
- puts optionParser.options.banner
-end
+end.parse!
+
+ s = Scrabbler.new(options[:language])
+ ARGV.each do |set|
+   r = s.scrabble(set, options[:thresh], options[:language])
+   puts '==> ' + set
+   r[0...options[:max]].each do |score|
+     puts "#{score.word} (#{score.score})" 
+     puts "-- #{score.explanation.join(", ")}" if options[:explanation]
+   end
+   puts ''
+ end

data/lib/array_extensions.rb

@@ -4,6 +4,8 @@
 
 # This module contains some extensions for the build-in array
 # type. Will not change existing methods
+require 'enumerator'
+
 module ArrayExtensions
   # removes the first entry in the array for which the test returns true
   def remove_first(&test)
@@ -13,15 +15,6 @@ module ArrayExtensions
     
     nil # nothing removed, nothing to return
   end
-  
-  def chunk(chunk_size = 100)
-    chunked = []
-    (0...self.length).step(chunk_size) do |i|
-      chunked[i/chunk_size] = self[i...(i+chunk_size)]
-    end 
-    
-    chunked 
-  end
 end
 
 class Array

data/lib/score.rb

@@ -1,22 +1,23 @@
 # Author::    Peter Maas (pfmmaas [at] gmail [dot] com)
 # Copyright:: Copyright (c) 2008
 # License::   Distributes under the same terms as Ruby
-#
-
-class Score
-   attr_accessor(:word, :score, :explanation)
+module SCRABBLR
+  # simple container for scrabble scores
+  class Score
+     attr_accessor(:word, :score, :explanation)
    
-   def initialize(word, score, explanation)
-     @word = word
-     @score = score
-     @explanation = explanation
-   end
+     def initialize(word, score, explanation)
+       @word = word
+       @score = score
+       @explanation = explanation
+     end
    
-   def inspect
-      "Scrabble score [word=#{@word}, score=#{@score}]"
-   end
+     def inspect
+        "Scrabble score [word=#{@word}, score=#{@score}]"
+     end
    
-   def <=> other
-     other.score <=> @score
-   end
+     def <=> other
+       other.score <=> @score
+     end
+  end
 end

data/lib/scrabbler.rb

@@ -10,104 +10,104 @@ require File.dirname(__FILE__) +'/array_extensions'
 require File.dirname(__FILE__) +'/score'
 require File.dirname(__FILE__) +'/vocabulary'
 
-
-# Class for solving scrabble puzzles
-class Scrabbler
-  MIN_WORD_SIZE = 3
+module SCRABBLR
+  # Class for solving scrabble puzzles
+  class Scrabbler
+    MIN_WORD_SIZE = 3
   
-  SCRABBLER_DICTIONARIES = {
-                            :nl => File.dirname(__FILE__) +"/data/nederlands.dict", 
-                            :en => File.dirname(__FILE__) +"/data/en-US.dict"
-                           }
+    SCRABBLER_DICTIONARIES = {
+                              :nl => File.dirname(__FILE__) +"/data/nederlands.dict", 
+                              :en => File.dirname(__FILE__) +"/data/en-US.dict"
+                             }
 
-  SCORES = YAML::load(File.new(File.dirname(__FILE__) + "/data/scores.yml").read)
-  MAX_THREADS = 10;
+    SCORES = YAML::load(File.new(File.dirname(__FILE__) + "/data/scores.yml").read)
+    MAX_THREADS = 10;
   
-  # TODO: rates in constant
+    # TODO: rates in constant
   
-  # initializes the Scrabbler with:
-  # - the array if the given object is of type array
-  # - the dictonary file specified by the given symbos (:nl, :en)
-  def initialize(_dictionary)
-    case _dictionary
-      when Symbol 
-        @dictionary = Vocabulary.new(File.read(SCRABBLER_DICTIONARIES[_dictionary]))
-        @dictionary.info = _dictionary
-      when Array
-        @dictionary = Vocabulary.new(_dictionary)
-        @dictionary.info = "based on supplied array"
+    # initializes the Scrabbler with:
+    # - the array if the given object is of type array
+    # - the dictonary file specified by the given symbos (:nl, :en)
+    def initialize(_dictionary)
+      case _dictionary
+        when Symbol 
+          @dictionary = Vocabulary.new(File.read(SCRABBLER_DICTIONARIES[_dictionary]))
+          @dictionary.info = _dictionary
+        when Array
+          @dictionary = Vocabulary.new(_dictionary)
+          @dictionary.info = "based on supplied array"
+      end
     end
-  end
     
-  # find possible solutions of the given array of letters
-  def scrabble(letters, min_score = 10, rating = :nl, wildcard = '$')
-    raise "Wildcard can not be a word character" if wildcard =~ /[\w]/
+    # find possible solutions of the given array of letters
+    def scrabble(letters, min_score = 10, rating = :nl, wildcard = '$')
+      raise "Wildcard can not be a word character" if wildcard =~ /[\w]/
       
-    letters = letters.scan(/[a-z#{wildcard}]/)
-    num_wildcards = letters.select{|c| c == wildcard}.length # count the number of wildcards
+      letters = letters.scan(/[a-z#{wildcard}]/)
+      num_wildcards = letters.select{|c| c == wildcard}.length # count the number of wildcards
     
-    # create a subset based on the word letters
-    dictonary_subset = @dictionary.calculate_subset(letters, wildcard, MIN_WORD_SIZE)
+      # create a subset based on the word letters
+      dictonary_subset = @dictionary.calculate_subset(letters, wildcard, MIN_WORD_SIZE)
     
-    scores, threads = [], []
-    chunks = dictonary_subset.chunk(@dictionary.words.length / (MAX_THREADS - 1) + 1)
-  
-    chunks.each do |chunk|
-       threads << Thread.new(chunk) do |c|
-        chunk_scores = []
-        chunk.each do |word|
-          score = calculate_score(letters, word, num_wildcards, rating)
-          chunk_scores << score if score && score.score > min_score
-        end
-        chunk_scores
-      end    
-    end
+      scores, threads = [], []
+
+      dictonary_subset.each_slice(@dictionary.words.length / (MAX_THREADS - 1) + 1) do |slice|
+         threads << Thread.new(slice) do |s|
+          slice_scores = []
+          s.each do |word|
+            score = calculate_score(letters, word, num_wildcards, rating)
+            slice_scores << score if score && score.score > min_score
+          end
+          slice_scores
+        end    
+      end
     
-    threads.each {|t| scores = scores + t.value} # gather values from all threads
+      threads.each {|t| scores = scores + t.value} # gather values from all threads
 
-    scores.sort
-  end
+      scores.sort
+    end
 
-  # calculate the score of the test_word. Doesn't return anything
-  # if it is impossible to create the word from the given letters
-  def calculate_score(letters, test_word, num_wild = 0, rating = :nl)
-    return if letters.length < test_word.length
+    # calculate the score of the test_word. Doesn't return anything
+    # if it is impossible to create the word from the given letters
+    def calculate_score(letters, test_word, num_wild = 0, rating = :nl)
+      return if letters.length < test_word.length
     
-    letters = letters.dup # make a copy, we'll use the array desctructively
-    score_sum, score_explanation = 0, []
+      letters = letters.dup # make a copy, we'll use the array desctructively
+      score_sum, score_explanation = 0, []
     
-    test_word.scan(/[a-z]/).each do |c|
-      if letters.include? c
-        letters.remove_first{|v| v == c} # we've used this letter, remove it
-        curr_rate = SCORES[rating][c.to_sym];
-        score_sum = score_sum + curr_rate
-        score_explanation << "#{c} (#{curr_rate})"
-      elsif num_wild > 0 # see if we've got any wildcards left
-        num_wild = num_wild - 1
-        score_explanation << "#{c} (wildcard)"
-      else
-        return
+      test_word.scan(/[a-z]/).each do |c|
+        if letters.include? c
+          letters.remove_first{|v| v == c} # we've used this letter, remove it
+          curr_rate = SCORES[rating][c.to_sym];
+          score_sum = score_sum + curr_rate
+          score_explanation << "#{c} (#{curr_rate})"
+        elsif num_wild > 0 # see if we've got any wildcards left
+          num_wild = num_wild - 1
+          score_explanation << "#{c} (wildcard)"
+        else
+          return
+        end
       end
-    end
     
-    # return the result
-    Score.new(test_word, score_sum , score_explanation)
-  end
+      # return the result
+      Score.new(test_word, score_sum , score_explanation)
+    end
     
-  def inspect
-    "scrabbler, dictionary: #{@dictionary.info}"
-  end
+    def inspect
+      "scrabbler, dictionary: #{@dictionary.info}"
+    end
   
-  def self.def_singletons(*args)
-    args.each do |arg|
-      module_eval <<-EOS
-        def self.get_#{arg}
-          @@instance_#{arg} ||= Scrabbler.new(:#{arg})
-        end
-      EOS
+    def self.def_singletons(*args)
+      args.each do |arg|
+        module_eval <<-EOS
+          def self.get_#{arg}
+            @@instance_#{arg} ||= Scrabbler.new(:#{arg})
+          end
+        EOS
+      end
     end
-  end
   
-  def_singletons *SCRABBLER_DICTIONARIES.keys
+    def_singletons *SCRABBLER_DICTIONARIES.keys
   
-end
+  end
+end

data/lib/vocabulary.rb

@@ -2,50 +2,52 @@
 # Copyright:: Copyright (c) 2008
 # License::   Distributes under the same terms as Ruby
 
-# Vocabulary is a simple dictionary with options for creating subsets
-class Vocabulary
-  attr_accessor(:words, :info, :index)
+module SCRABBLR
+  # Vocabulary is a simple dictionary with options for creating subsets
+  class Vocabulary
+    attr_accessor(:words, :info, :index)
   
-  # removes non-word characters
-  SANITIZE_FILTER = proc{|v| v.chomp.downcase.gsub(/\W/,'')}
+    # removes non-word characters
+    SANITIZE_FILTER = proc{|v| v.chomp.downcase.gsub(/\W/,'')}
   
-  def initialize(words)
-    @words = words.map(&SANITIZE_FILTER)
-    build_index
-  end
+    def initialize(words)
+      @words = words.map(&SANITIZE_FILTER)
+      build_index
+    end
   
-  def build_index
-    @index = Hash.new { |hash, key| hash[key] = [] }
-    @words.each do |w|
-      w.scan(/[a-z]/).uniq.each do |c|
-        @index[c.to_sym] << w
+    def build_index
+      @index = Hash.new { |hash, key| hash[key] = [] }
+      @words.each do |w|
+        w.scan(/[a-z]/).uniq.each do |c|
+          @index[c.to_sym] << w
+        end
       end
     end
-  end
   
-  def calculate_subset(letters, wildcard, min_word_size = 3)
-    # create a subset based on the word letters
-    lf = length_filter(min_word_size..letters.length)
+    def calculate_subset(letters, wildcard, min_word_size = 3)
+      # create a subset based on the word letters
+      lf = length_filter(min_word_size..letters.length)
     
-    if letters.include? wildcard
-      subset = @words.select(&lf)
-    else
-      subset = []
-      letters.uniq.each do |c|
-        subset = subset + index[c.to_sym]
+      if letters.include? wildcard
+        subset = @words.select(&lf)
+      else
+        subset = []
+        letters.uniq.each do |c|
+          subset = subset + index[c.to_sym]
+        end
+        subset = subset.select(&lf)
+        subset = subset.uniq.grep(create_pattern(letters, min_word_size))
       end
-      subset = subset.select(&lf)
-      subset = subset.uniq.grep(create_pattern(letters, min_word_size))
-    end
     
-    subset
-  end
+      subset
+    end
   
-  def length_filter(range)
-    proc{|s| range.include? s.length}
-  end
+    def length_filter(range)
+      proc{|s| range.include? s.length}
+    end
   
-  def create_pattern(letters, min_word_size = 3)
-    /^[#{letters.join}]{#{min_word_size},#{letters.length}}$/
+    def create_pattern(letters, min_word_size = 3)
+      /^[#{letters.join}]{#{min_word_size},#{letters.length}}$/
+    end
   end
 end

data/test/test_array_extensions.rb

@@ -20,12 +20,5 @@ class TestScrabbler < Test::Unit::TestCase
       r.remove_first{|i| raise BlockCalled}      
     end
   end
-  
-  def test_chunk
-    r = %w(the quick brown fox jumps over the lazy dog)
-    assert_equal([%w(the quick brown),%w(fox jumps over),%w(the lazy dog)], r.chunk(3))
-    
-    r = %w(the quick brown fox jumps over the lazy dog but didn't jump over the fast bunny)
-    assert_equal([%w(the quick brown),%w(fox jumps over),%w(the lazy dog), %w(but didn't jump), %w(over the fast), %w(bunny)], r.chunk(3))
-  end
+
 end

data/test/test_helper.rb

@@ -1,6 +1,8 @@
 require 'test/unit'
 require File.dirname(__FILE__) + '/../lib/scrabbler.rb'
 
+include SCRABBLR
+
 # class to use in
 class BlockCalled < RuntimeError
 end

metadata

@@ -3,7 +3,7 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: scrabbler
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.1.3
 date: 2008-01-30 00:00:00 +01:00
 summary: A bruteforce word finder for scrabble.
 require_paths: