pressletter 0.0.1

data/bin/pressletter

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'pressletter'
+
+Pressletter::Shell::CLI.new.main

data/lib/pressletter.rb

@@ -0,0 +1,16 @@
+module Pressletter
+  module Shell
+    # This namespace is for the minimal interoperable imperative code
+  end
+
+  module Core
+    # This namespace is for the private functional code
+  end
+
+  module Values
+    # This namespace is for behavioral-less values which
+    # =>  serve as messages between core & shell and between shells.
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), "**", "*.rb")].each {|file| require file }

data/lib/pressletter/core/create_letters.rb

@@ -0,0 +1,19 @@
+module Pressletter::Core
+  def create_letters(input)
+    Pressletter::Values::Letters.new(
+      ensure_alphabetical(
+        input.chomp.split('').
+          map { |c| c.upcase }.
+            reject { |c| c == ' ' }.compact.sort
+      )
+    )
+  end
+
+private
+
+  def ensure_alphabetical(letters)
+    raise "Letters only!" if letters.any? {|l| l =~ /[^A-Z]/}
+    letters
+  end
+
+end

data/lib/pressletter/core/find_words.rb

@@ -0,0 +1,23 @@
+module Pressletter::Core
+  def find_words(dictionary, letters)
+    Pressletter::Values::Words.new(
+      dictionary.as_array.map do |word|
+        word if letters_can_buy?(letters, word)
+      end.compact
+    )
+  end
+
+private
+
+  def letters_can_buy?(letters, word)
+    letters = letters.as_hash.dup
+    word.dup.split('').all? do |char|
+      decrement_char!(char, letters)
+    end
+  end
+
+  def decrement_char!(char, letters)
+    letters[char] -= 1 if letters[char] && letters[char] > 0
+  end
+
+end

data/lib/pressletter/core/load_dictionary.rb

@@ -0,0 +1,5 @@
+module Pressletter::Core
+  def load_dictionary(location)
+    Dictionary.new(File.read(location).split("\n"))
+  end
+end

data/lib/pressletter/core/print_words.rb

@@ -0,0 +1,5 @@
+module Pressletter::Core
+  def print_words(words)
+    words.as_array.join("\n")
+  end
+end

data/lib/pressletter/core/solve.rb

@@ -0,0 +1,6 @@
+module Pressletter::Core
+  def solve(config, letters)
+    sort_words(find_words(load_dictionary(config.dictionary_location), letters))
+  end
+end
+

data/lib/pressletter/core/sort_words.rb

@@ -0,0 +1,11 @@
+module Pressletter::Core
+  def sort_words(words)
+    Pressletter::Values::Words.new(words.as_array.sort(&method(:size_then_alphabet)))
+  end
+
+private
+
+  def size_then_alphabet(word_1, word_2)
+    [-word_1.size, word_1] <=> [-word_2.size, word_2]
+  end
+end

data/lib/pressletter/default_config.rb

@@ -0,0 +1,5 @@
+module Pressletter
+  def self.default_config
+    Pressletter::Values::Config.new(File.expand_path("../../../assets/dictionary.txt", __FILE__))
+  end
+end

data/lib/pressletter/shell/api.rb

@@ -0,0 +1,25 @@
+module Pressletter
+  module Shell
+    class API
+      include Pressletter::Core
+
+      def initialize(config=Pressletter::default_config)
+        @config = config
+      end
+
+      def solve_letters(letters)
+        solve(@config, create_letters(ensure_string(letters))).as_array
+      end
+
+    private
+
+      def ensure_string(input)
+        input.respond_to?(:join) ? input.join : input
+      end
+    end
+  end
+
+  def self.solve(letters, config=Pressletter::default_config)
+    Pressletter::Shell::API.new(config).solve_letters(letters)
+  end
+end

data/lib/pressletter/shell/cli.rb

@@ -0,0 +1,15 @@
+module Pressletter::Shell
+  class CLI
+    include Pressletter::Core
+
+    def initialize(config = Pressletter::default_config, reads_input = ReadsInput.new, writes_output = WritesOutput.new)
+      @config = config
+      @reads_input = reads_input
+      @writes_output = writes_output
+    end
+
+    def main
+      @writes_output.write(print_words(solve(@config, create_letters(@reads_input.read))))
+    end
+  end
+end

data/lib/pressletter/shell/reads_input.rb

@@ -0,0 +1,10 @@
+module Pressletter::Shell
+  class ReadsInput
+    def read
+      ARGV[0] || begin
+        puts "Please enter candidate Letterpress letters, then press <return>:\n"
+        gets
+      end
+    end
+  end
+end

data/lib/pressletter/shell/writes_output.rb

@@ -0,0 +1,7 @@
+module Pressletter::Shell
+  class WritesOutput
+    def write(s)
+      puts(s)
+    end
+  end
+end

data/lib/pressletter/values/config.rb

@@ -0,0 +1,3 @@
+module Pressletter::Values
+  Config = Struct.new(:dictionary_location)
+end

data/lib/pressletter/values/dictionary.rb

@@ -0,0 +1,10 @@
+class Dictionary
+  def initialize(dictionary)
+    @dictionary = dictionary
+  end
+
+  def as_array
+    @dictionary
+  end
+end
+

data/lib/pressletter/values/letters.rb

@@ -0,0 +1,18 @@
+module Pressletter::Values
+  class Letters
+    def initialize(letters)
+      @letters = letters
+    end
+
+    def as_array
+      @letters
+    end
+
+    def as_hash
+      @hash ||= @letters.inject({}) do |h,l|
+        h[l] = h[l] ? h[l] + 1 : 1
+        h
+      end
+    end
+  end
+end

data/lib/pressletter/values/words.rb

@@ -0,0 +1,11 @@
+module Pressletter::Values
+  class Words
+    def initialize(words)
+      @words = words
+    end
+
+    def as_array
+      @words
+    end
+  end
+end

data/lib/pressletter/version.rb

@@ -0,0 +1,3 @@
+module Pressletter
+  VERSION = "0.0.1"
+end

data/pressletter.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pressletter/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "pressletter"
+  gem.version       = Pressletter::VERSION
+  gem.authors       = ["Justin Searls"]
+  gem.email         = ["justin@testdouble.com"]
+  gem.description   = <<-EOF
+    pressletter is a tool for solving Letterpress puzzles. Using the
+    `pressletter` binary like this:
+
+    $ pressletter eiptctbntymeiphoxvitkmzib
+
+    The argument is a list of all the letters on a pressletter board
+    and will yield an ordered list (from longest to shorted) of all
+    legal words that can be made with the provided letters.
+  EOF
+  gem.summary       = %q{A tool for solving Letterpress puzzles}
+  gem.homepage      = "https://github.com/searls/pressletter"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "rspec", "~> 2.12.0"
+  gem.add_development_dependency "rspec-given", "~> 2.2.0"
+  gem.add_development_dependency "gimme", "~> 0.3.4"
+end

data/spec/fixtures/simple_dict.txt

@@ -0,0 +1,7 @@
+COT
+COPTIC
+EPITOME
+MEMITIC
+TENT
+TINT
+ZEBRAPANTS

data/spec/lib/pressletter/core/create_letters_spec.rb

@@ -0,0 +1,14 @@
+describe "Pressletter::Core#create_letters" do
+  include Pressletter::Core
+
+  context "several letters" do
+    When(:result) { create_letters("c a ba\n") }
+    Then { result.as_array.should == ["A", "A", "B", "C"] }
+    Then { result.as_hash.should == { "A" => 2, "B" => 1, "C" => 1 }}
+  end
+
+  context "containing a non-alpha character" do
+    Then { lambda { create_letters("1") }.should raise_error "Letters only!" }
+  end
+
+end

data/spec/lib/pressletter/core/find_words_spec.rb

@@ -0,0 +1,20 @@
+describe "Pressletter::Core#find_words" do
+  include Pressletter::Core
+
+  context "one word dictionary" do
+    Given(:dictionary) { Dictionary.new(["FOOD"]) }
+    context "and we've got the letters" do
+      Given(:letters) { Pressletter::Values::Letters.new(["D","F","O","O"]) }
+      When(:result) { find_words(dictionary, letters) }
+      Then { result.as_array.should == ["FOOD"] }
+    end
+
+    context "and we don't got the letters" do
+      Given(:letters) { Pressletter::Values::Letters.new(["D","F","O"]) }
+      When(:result) { find_words(dictionary, letters) }
+      Then { result.as_array.should == [] }
+    end
+  end
+
+
+end

data/spec/lib/pressletter/core/load_dictionary_spec.rb

@@ -0,0 +1,23 @@
+describe "Pressletter::Core#load_dictionary" do
+  include Pressletter::Core
+
+  Given(:content) do
+    <<-TXT.gsub /^\s+/, ""
+    A
+    ABC
+    DOG
+    PANDA
+    TXT
+  end
+  Given(:path) { tempfile_location_containing(content) }
+  When(:result) { load_dictionary(path) }
+  Then { result.as_array.should == ["A", "ABC", "DOG", "PANDA"]}
+
+  def tempfile_location_containing(content)
+    require 'tempfile'
+    f = Tempfile.new("not-unique")
+    f.write(content)
+    f.close
+    f.path
+  end
+end

data/spec/lib/pressletter/core/print_words_spec.rb

@@ -0,0 +1,12 @@
+describe "Pressletter::Core#print_words" do
+  include Pressletter::Core
+
+  Given(:words) { Pressletter::Values::Words.new(["AL", "BAR", "ZEBRA"]) }
+  When(:result) { print_words(words) }
+  Then do
+    result.should == "AL\n" +
+                     "BAR\n" +
+                     "ZEBRA"
+
+  end
+end

data/spec/lib/pressletter/core/solve_spec.rb

@@ -0,0 +1,8 @@
+describe "Pressletter::Core#solve" do
+  include Pressletter::Core
+
+  Given(:config) { Pressletter::Values::Config.new(File.expand_path("../../../../fixtures/simple_dict.txt", __FILE__)) }
+  Given(:letters) { Pressletter::Values::Letters.new("eiptctbntymeiphoxvitkmzib".upcase.split('')) }
+  When(:result) { solve(config, letters) }
+  Then { result.as_array.should == ["EPITOME", "MEMITIC", "TENT", "TINT", "COT"] }
+end

data/spec/lib/pressletter/core/sort_words_spec.rb

@@ -0,0 +1,7 @@
+describe "Pressletter::Core#sort_words" do
+  include Pressletter::Core
+
+  Given(:words) { Pressletter::Values::Words.new(["AL", "BAR", "CAR", "ZEBRA"]) }
+  When(:result) { sort_words(words) }
+  Then { result.as_array.should == ["ZEBRA", "BAR", "CAR", "AL"] }
+end

data/spec/lib/pressletter/shell/api_spec.rb

@@ -0,0 +1,26 @@
+module Pressletter::Shell
+  describe "ruby API" do
+    shared_examples_for "API methods" do
+      Given(:letters) { "eiptctbntymeiphoxvitkmzib".split('') }
+      Then { result.should == ["EPITOME", "MEMITIC", "TENT", "TINT", "COT"] }
+    end
+
+    Given(:config) { Pressletter::Values::Config.new(File.expand_path("../../../../fixtures/simple_dict.txt", __FILE__)) }
+
+    describe API do
+      subject { API.new(config) }
+
+      describe "#solve" do
+        it_behaves_like "API methods" do
+          When(:result) { subject.solve_letters(letters) }
+        end
+      end
+    end
+
+    describe "top-level DSL" do
+      it_behaves_like "API methods" do
+        When(:result) { Pressletter.solve(letters, config) }
+      end
+    end
+  end
+end

data/spec/lib/pressletter/shell/cli_spec.rb

@@ -0,0 +1,22 @@
+module Pressletter::Shell
+  describe CLI do
+    Given(:config) { Pressletter::Values::Config.new(File.expand_path("../../../../fixtures/simple_dict.txt", __FILE__)) }
+    Given(:reads_input) { gimme(ReadsInput) }
+    Given(:writes_output) { gimme(WritesOutput) }
+
+    subject { CLI.new(config, reads_input, writes_output) }
+
+    describe "#main" do
+      Given { give(reads_input).read {"eiptctbntymeiphoxvitkmzib"} }
+      When { subject.main }
+      Then do
+        verify(writes_output).write contains "EPITOME\n"+
+                                             "MEMITIC\n" +
+                                             "TENT\n" +
+                                             "TINT\n" +
+                                             "COT"
+      end
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'rspec'
+require 'gimme'
+require 'rspec/given'
+require 'pressletter'
+
+
+module GimmeMatchers
+  class Contains
+    def initialize(expected)
+      @expected = expected
+    end
+    def matches?(actual)
+      actual.include?(@expected)
+    end
+  end
+  def contains(expected)
+    Contains.new(expected)
+  end
+end
+include GimmeMatchers
+
+RSpec.configure do |config|
+  config.mock_framework = Gimme::RSpecAdapter
+
+  config.after(:each) do
+    Gimme.reset
+  end
+end