ruby-dictionary 1.0.1 → 1.1.0

data/.travis.yml

@@ -1,5 +1,10 @@
 language: ruby
+
 rvm:
   - 1.9.3
   - 2.0.0
   - ruby-head
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/README.md

@@ -53,6 +53,32 @@ the provided string.
     dictionary.starting_with('bee')  # => ["bee", "been", "bees"]
     dictionary.starting_with('foo')  # => []
 
+### Case Sensitivity
+
+By default, a new `Dictionary` is case-insensitive, meaning "bee", "Bee", and
+"BEE" are all considered to be the same, regardless of adding to the dictionary
+or searching within it.
+
+However, you can choose to use case-sensitive dictionary by passing an optional
+`true` parameter to both the `#new` and `#from_file` methods.
+
+    dictionary = Dictionary.new(%w(Alpha Beta), true)
+    dictionary.exists?('Alpha')      # => true
+    dictionary.exists?('alpha')      # => false
+
+    dictionary = Dictionary.from_file('restaurants.txt', "\n", true)
+    dictionary.starting_with('Mc')   # => ["McDonald's"]
+    dictionary.starting_with('mc')   # => []
+
+Additionally, you can determine whether a dictionary is case-sensitive via the
+`#case_sensitive?` method.
+
+    dictionary = Dictionary.new([])
+    dictionary.case_sensitive?       # => false
+
+    dictionary = Dictionary.new([], true)
+    dictionary.case_sensitive?       # => true
+
 ## Contributing
 
 1. Fork it

data/lib/ruby-dictionary/dictionary.rb

@@ -4,8 +4,12 @@ require 'zlib'
 require 'ruby-dictionary/word_path'
 
 class Dictionary
-  def initialize(word_list)
-    @word_path = parse_words(word_list)
+  def initialize(word_list, case_sensitive = false)
+    @word_path = parse_words(word_list, case_sensitive)
+  end
+
+  def case_sensitive?
+    @word_path.case_sensitive?
   end
 
   def exists?(word)
@@ -14,7 +18,9 @@ class Dictionary
   end
 
   def starting_with(prefix)
-    prefix = prefix.to_s.strip.downcase
+    prefix = prefix.to_s.strip
+    prefix = prefix.downcase unless case_sensitive?
+
     path = word_path(prefix)
     return [] if path.nil?
 
@@ -42,11 +48,11 @@ class Dictionary
     inspect
   end
 
-  def self.from_file(path, separator = "\n")
+  def self.from_file(path, separator = "\n", case_sensitive = false)
     contents = case path
                  when String then File.read(path)
                  when File then path.read
-                 else raise ArgumentError, "path must be a String or File"
+                 else raise ArgumentError, 'path must be a String or File'
                end
 
     if contents.start_with?("\x1F\x8B")
@@ -54,15 +60,15 @@ class Dictionary
       contents = gz.read
     end
 
-    new(contents.split(separator))
+    new(contents.split(separator), case_sensitive)
   end
 
   private
 
-  def parse_words(word_list)
-    raise ArgumentError, "word_list should be an array of strings" unless word_list.kind_of?(Array)
+  def parse_words(word_list, case_sensitive)
+    raise ArgumentError, 'word_list should be an array of strings' unless word_list.kind_of?(Array)
 
-    WordPath.new.tap do |word_path|
+    WordPath.new(case_sensitive).tap do |word_path|
       word_list.each { |word| word_path << word.to_s }
     end
   end

data/lib/ruby-dictionary/version.rb

@@ -1,3 +1,3 @@
 class Dictionary
-  VERSION = '1.0.1'
+  VERSION = '1.1.0'
 end

data/lib/ruby-dictionary/word_path.rb

@@ -1,10 +1,15 @@
 class Dictionary
   class WordPath
-    def initialize
+    def initialize(case_sensitive)
+      @case_sensitive = !!case_sensitive
       @is_leaf = false
       @word_paths = {}
     end
 
+    def case_sensitive?
+      @case_sensitive
+    end
+
     def leaf?
       @is_leaf
     end
@@ -14,13 +19,15 @@ class Dictionary
     end
 
     def <<(word)
-      raise ArgumentError, "must be a string" unless word.kind_of?(String)
-      _append(word.strip.downcase)
+      raise ArgumentError, 'must be a string' unless word.kind_of?(String)
+      word = word.downcase unless @case_sensitive
+      _append(word.strip)
     end
 
     def find(word)
-      raise ArgumentError, "must be a string" unless word.kind_of?(String)
-      _find(word.strip.downcase)
+      raise ArgumentError, 'must be a string' unless word.kind_of?(String)
+      word = word.downcase unless @case_sensitive
+      _find(word.strip)
     end
 
     def suffixes
@@ -33,7 +40,7 @@ class Dictionary
     end
 
     def hash
-      self.class.hash ^ @is_leaf.hash ^ @word_paths.hash
+      self.class.hash ^ @is_leaf.hash ^ @word_paths.hash ^ @case_sensitive.hash
     end
 
     def ==(obj)
@@ -65,7 +72,7 @@ class Dictionary
       return if word.empty?
 
       char = word[0]
-      word_path = @word_paths[char] ||= self.class.new
+      word_path = @word_paths[char] ||= self.class.new(@case_sensitive)
 
       if word.size == 1
         word_path.leaf = true

data/spec/ruby-dictionary/dictionary_spec.rb

@@ -1,51 +1,126 @@
 require 'spec_helper'
 
 describe Dictionary do
-  subject { Dictionary.new(word_list) }
+  subject { Dictionary.new(word_list, case_sensitive) }
 
   let(:word_list) { %w(a ab abs absolute absolutely be bee bees been zoo zoos zebra yuck) }
+  let(:case_sensitive) { false }
 
-  describe '#exists?' do
-    it 'finds existing single-letter words' do
-      subject.exists?('a').should be_true
+  describe '#case_sensitive?' do
+    describe 'when case-insensitive' do
+      it { should_not be_case_sensitive }
     end
 
-    it 'finds existing multi-letter words' do
-      subject.exists?('ab').should be_true
+    describe 'when case-sensitive' do
+      let(:case_sensitive) { true }
+
+      it { should be_case_sensitive }
     end
+  end
+
+  describe '#exists?' do
+    describe 'when case-insensitive' do
+      it 'finds existing single-letter words regardless of casing' do
+        subject.exists?('a').should be_true
+        subject.exists?('A').should be_true
+      end
 
-    it "doesn't find non-existing single-letter words" do
-      subject.exists?('e').should be_false
+      it 'finds existing multi-letter words regardless of casing' do
+        subject.exists?('ab').should be_true
+        subject.exists?('AB').should be_true
+      end
+
+      it "doesn't find non-existing single-letter words regardless of casing" do
+        subject.exists?('e').should be_false
+        subject.exists?('E').should be_false
+      end
+
+      it "doesn't find non-existing multi-letter words regardless of casing" do
+        subject.exists?('eggsactly').should be_false
+        subject.exists?('EGGSACTLY').should be_false
+      end
     end
 
-    it "doesn't find non-existing multi-letter words" do
-      subject.exists?('eggsactly').should be_false
+    describe 'when case-sensitive' do
+      let(:case_sensitive) { true }
+
+      it 'finds existing single-letter words of the same casing' do
+        subject.exists?('a').should be_true
+      end
+
+      it 'finds existing multi-letter words of the same casing' do
+        subject.exists?('ab').should be_true
+      end
+
+      it "doesn't find existing single-letter words of a different casing" do
+        subject.exists?('A').should be_false
+      end
+
+      it "doesn't find existing multi-letter words of a different casing" do
+        subject.exists?('AB').should be_false
+      end
+
+      it "doesn't find non-existing single-letter words of any casing" do
+        subject.exists?('e').should be_false
+        subject.exists?('E').should be_false
+      end
+
+      it "doesn't find non-existing multi-letter words of any casing" do
+        subject.exists?('eggsactly').should be_false
+        subject.exists?('EGGSACTLY').should be_false
+      end
     end
   end
 
   describe '#starting_with' do
-    it 'finds all words starting with a single letter' do
-      words = subject.starting_with('a')
-      words.size.should eq 5
-      words.should include 'a'
-      words.should include 'absolutely'
-      words.each { |word| word.should start_with 'a' }
-    end
+    describe 'when case-insensitive' do
+      it 'finds all words starting with a single letter regardless of casing' do
+        %w(a A).each do |prefix|
+          subject.starting_with(prefix).should eq %w(a ab abs absolute absolutely)
+        end
+      end
 
-    it 'finds all words starting with multiple letters' do
-      words = subject.starting_with('abso')
-      words.size.should eq 2
-      words.should include 'absolute'
-      words.should include 'absolutely'
-      words.each { |word| word.should start_with 'a' }
-    end
+      it 'finds all words starting with multiple letters regardless of casing' do
+        %w(abso ABSO).each do |prefix|
+          subject.starting_with(prefix).should eq %w(absolute absolutely)
+        end
+      end
 
-    it 'finds no words starting with unmatched single letter' do
-      subject.starting_with('e').should be_empty
+      it 'finds no words starting with unmatched single letter regardless of casing' do
+        %w(e E).each do |prefix|
+          subject.starting_with(prefix).should be_empty
+        end
+      end
+
+      it 'finds no words starting with unmatched multiple letters regardless of casing' do
+        %w(absolutetastic ABSOLUTETASTIC).each do |prefix|
+          subject.starting_with(prefix).should be_empty
+        end
+      end
     end
 
-    it 'finds no words starting with unmatched multiple letters' do
-      subject.starting_with('absolutetastic').should be_empty
+    describe 'when case-sensitive' do
+      let(:case_sensitive) { true }
+
+      it 'finds all words starting with a single letter of the same casing' do
+        subject.starting_with('a').should eq %w(a ab abs absolute absolutely)
+        subject.starting_with('A').should be_empty
+      end
+
+      it 'finds all words starting with multiple letters of the same casing' do
+        subject.starting_with('abso').should eq %w(absolute absolutely)
+        subject.starting_with('ABSO').should be_empty
+      end
+
+      it 'finds no words starting with unmatched single letter of the same casing' do
+        subject.starting_with('e').should be_empty
+        subject.starting_with('E').should be_empty
+      end
+
+      it 'finds no words starting with unmatched multiple letters of the same casing' do
+        subject.starting_with('absolutetastic').should be_empty
+        subject.starting_with('ABSOLUTETASTIC').should be_empty
+      end
     end
   end
 
@@ -58,7 +133,7 @@ describe Dictionary do
   end
 
   describe '.from_file' do
-    subject { Dictionary.from_file(dictionary_path, separator) }
+    subject { Dictionary.from_file(dictionary_path, separator, case_sensitive) }
 
     let(:separator) { "\n" }
 
@@ -75,6 +150,16 @@ describe Dictionary do
           subject.starting_with(letter).should be_empty
         end
       end
+
+      describe 'when case-insensitive' do
+        let(:case_sensitive) { false }
+        it { should_not be_case_sensitive }
+      end
+
+      describe 'when case-sensitive' do
+        let(:case_sensitive) { true }
+        it { should be_case_sensitive }
+      end
     end
 
     describe 'with compressed file' do

data/spec/ruby-dictionary/word_path_spec.rb

@@ -1,7 +1,21 @@
 require 'spec_helper'
 
 describe Dictionary::WordPath do
-  subject { Dictionary::WordPath.new }
+  subject { Dictionary::WordPath.new(case_sensitive) }
+
+  let(:case_sensitive) { false }
+
+  describe '#case_sensitive?' do
+    describe 'when case-insensitive' do
+      it { should_not be_case_sensitive }
+    end
+
+    describe 'when case-sensitive' do
+      let(:case_sensitive) { true }
+
+      it { should be_case_sensitive }
+    end
+  end
 
   describe '#leaf=' do
     it 'should set to false' do
@@ -16,44 +30,97 @@ describe Dictionary::WordPath do
   end
 
   describe '#find' do
-    before do
-      subject << 'potato'
-    end
+    describe 'when case-insensitive' do
+      before do
+        subject << 'potato'
+      end
 
-    it 'finds existing word paths' do
-      word_path = subject.find('potat')
-      word_path.should be_a Dictionary::WordPath
-      word_path.should eq Dictionary::WordPath.new.tap { |wp| wp << 'o' }
+      it 'finds existing word paths of matching case-sensitivity' do
+        word_path = subject.find('potat')
+        word_path.should be_a Dictionary::WordPath
+        word_path.should eq Dictionary::WordPath.new(case_sensitive).tap { |wp| wp << 'o' }
+      end
+
+      it 'finds existing word paths of unmatching case-sensitivity' do
+        word_path = subject.find('poTAt')
+        word_path.should be_a Dictionary::WordPath
+        word_path.should eq Dictionary::WordPath.new(case_sensitive).tap { |wp| wp << 'o' }
+      end
+
+      it 'does not find nonexistent word paths' do
+        subject.find('potable').should be_nil
+      end
     end
 
-    it 'does not find nonexistent word paths' do
-      subject.find('potable').should be_nil
+    describe 'when case-sensitive' do
+      before do
+        subject << 'poTAto'
+      end
+
+      let(:case_sensitive) { true }
+
+      it 'finds existing word paths of matching case-sensitivity' do
+        word_path = subject.find('poTAt')
+        word_path.should be_a Dictionary::WordPath
+        word_path.should eq Dictionary::WordPath.new(case_sensitive).tap { |wp| wp << 'o' }
+      end
+
+      it 'does not find existing word paths of unmatching case-sensitivity' do
+        subject.find('potat').should be_nil
+      end
+
+      it 'does not find nonexistent word paths' do
+        subject.find('potat').should be_nil
+      end
     end
   end
 
   describe '#<<' do
     before do
-      subject.find('pot').should be_nil
+      subject << 'potato'
     end
 
-    it 'appends word to dictionary' do
-      subject << 'potato'
-      subject.find('pot').should_not be_nil
+    describe 'when case-insensitive' do
+      it 'appends case-insensitive word to word path' do
+        subject.find('potato').should be_a Dictionary::WordPath
+        subject.find('poTAto').should eq subject.find('potato')
+      end
+    end
+
+    describe 'when case-sensitive' do
+      let(:case_sensitive) { true }
+
+      it 'appends case-sensitive word to word path' do
+        subject.find('potato').should be_a Dictionary::WordPath
+        subject.find('poTAto').should be_nil
+      end
     end
   end
 
   describe '#suffixes' do
     before do
       subject << 'pot'
-      subject << 'potato'
-      subject << 'potable'
+      subject << 'poTAto'
+      subject << 'potABle'
+      subject << 'POTTY'
       subject << 'pert'
       subject << 'jar'
     end
 
-    it 'finds all words with the given suffix' do
-      word = subject.find('pot')
-      word.suffixes.should eq %w(ato able)
+    describe 'when case-insensitive' do
+      it 'finds all words with the given suffix' do
+        word = subject.find('pot')
+        word.suffixes.should eq %w(ato able ty)
+      end
+    end
+
+    describe 'when case-sensitive' do
+      let(:case_sensitive) { true }
+
+      it 'finds all words with the given suffix' do
+        word = subject.find('pot')
+        word.suffixes.should eq %w(ABle)
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-dictionary
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-24 00:00:00.000000000 Z
+date: 2013-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2157608560 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2157608560
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2157608140 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +37,12 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2157608140
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ! "Dictionary class for ruby that allows for checking\n                         existence
   and finding words starting with a given\n                         prefix."
 email:
@@ -73,15 +83,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3725738245159260742
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3725738245159260742
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Simple dictionary class for checking existence of words