ruby-dictionary 1.1.0 → 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 20430da0e54cba0c7228d1213a4f17dc51b35566
+  data.tar.gz: b745c2a145c235e8e53547b5d2edd3daf2b4fcbe
+SHA512:
+  metadata.gz: 48cc361c6dcc15ab3183ce263d5d5fdd886655e7ca9eb44cf87d7d9c2395ec013ba3cb173dc2cfc29e71e7d4322190213664fbe79d7d8f5c50b22c7f0f58fde2
+  data.tar.gz: d4a9a1dae9da2b6fc23cd0839610e88d746174ec1a387e6f7bf567e22213e54c0f2a9763a0ca6f5739877cc7d03b45ee18d796137eb2f93c6900455ba7ae9b8d

data/.rspec

@@ -0,0 +1 @@
+--color

data/README.md

@@ -53,6 +53,13 @@ the provided string.
     dictionary.starting_with('bee')  # => ["bee", "been", "bees"]
     dictionary.starting_with('foo')  # => []
 
+The `#prefixes` method returns a sorted array of all the words appearing in the
+beginning of the provided string.
+
+    dictionary.prefixes('abstract')  # => ["a", "ab", "abs"]
+    dictionary.prefixes('bend')      # => ["be", "bend"]
+
+
 ### Case Sensitivity
 
 By default, a new `Dictionary` is case-insensitive, meaning "bee", "Bee", and

data/lib/ruby-dictionary/dictionary.rb

@@ -32,6 +32,14 @@ class Dictionary
     words.sort!
   end
 
+  def prefixes(string)
+    string = string.to_s.strip
+    string = string.downcase unless case_sensitive?
+
+    @word_path.find_prefixes(string).sort
+  end
+
+
   def hash
     self.class.hash ^ @word_path.hash
   end

data/lib/ruby-dictionary/version.rb

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

data/lib/ruby-dictionary/word_path.rb

@@ -39,6 +39,13 @@ class Dictionary
       end
     end
 
+    def find_prefixes(string)
+      raise ArgumentError, 'must be a string' unless string.kind_of?(String)
+      string = string.downcase unless @case_sensitive
+      _find_prefixes(string.strip)
+    end
+
+
     def hash
       self.class.hash ^ @is_leaf.hash ^ @word_paths.hash ^ @case_sensitive.hash
     end
@@ -68,6 +75,18 @@ class Dictionary
       end
     end
 
+    def _find_prefixes(str)
+      char = str[0]
+
+      word_path = @word_paths[char]
+      return [] unless word_path
+
+      [].tap do |prefixes|
+        prefixes << char if word_path.leaf?
+        prefixes.concat(word_path._find_prefixes(str[1, str.size]).collect { |prefix| "#{char}#{prefix}" })
+      end
+    end
+
     def _append(word)
       return if word.empty?
 

data/spec/ruby-dictionary/dictionary_spec.rb

@@ -21,23 +21,23 @@ describe Dictionary do
   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
+        expect(subject.exists?('a')).to be_truthy
+        expect(subject.exists?('A')).to be_truthy
       end
 
       it 'finds existing multi-letter words regardless of casing' do
-        subject.exists?('ab').should be_true
-        subject.exists?('AB').should be_true
+        expect(subject.exists?('ab')).to be_truthy
+        expect(subject.exists?('AB')).to be_truthy
       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
+        expect(subject.exists?('e')).to be_falsey
+        expect(subject.exists?('E')).to be_falsey
       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
+        expect(subject.exists?('eggsactly')).to be_falsey
+        expect(subject.exists?('EGGSACTLY')).to be_falsey
       end
     end
 
@@ -45,29 +45,29 @@ describe Dictionary do
       let(:case_sensitive) { true }
 
       it 'finds existing single-letter words of the same casing' do
-        subject.exists?('a').should be_true
+        expect(subject.exists?('a')).to be_truthy
       end
 
       it 'finds existing multi-letter words of the same casing' do
-        subject.exists?('ab').should be_true
+        expect(subject.exists?('ab')).to be_truthy
       end
 
       it "doesn't find existing single-letter words of a different casing" do
-        subject.exists?('A').should be_false
+        expect(subject.exists?('A')).to be_falsey
       end
 
       it "doesn't find existing multi-letter words of a different casing" do
-        subject.exists?('AB').should be_false
+        expect(subject.exists?('AB')).to be_falsey
       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
+        expect(subject.exists?('e')).to be_falsey
+        expect(subject.exists?('E')).to be_falsey
       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
+        expect(subject.exists?('eggsactly')).to be_falsey
+        expect(subject.exists?('EGGSACTLY')).to be_falsey
       end
     end
   end
@@ -76,25 +76,25 @@ describe Dictionary do
     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)
+          expect(subject.starting_with(prefix)).to eq %w(a ab abs absolute absolutely)
         end
       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)
+          expect(subject.starting_with(prefix)).to eq %w(absolute absolutely)
         end
       end
 
       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
+          expect(subject.starting_with(prefix)).to 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
+          expect(subject.starting_with(prefix)).to be_empty
         end
       end
     end
@@ -103,33 +103,64 @@ describe Dictionary 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
+        expect(subject.starting_with('a')).to eq %w(a ab abs absolute absolutely)
+        expect(subject.starting_with('A')).to 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
+        expect(subject.starting_with('abso')).to eq %w(absolute absolutely)
+        expect(subject.starting_with('ABSO')).to 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
+        expect(subject.starting_with('e')).to be_empty
+        expect(subject.starting_with('E')).to 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
+        expect(subject.starting_with('absolutetastic')).to be_empty
+        expect(subject.starting_with('ABSOLUTETASTIC')).to be_empty
       end
     end
   end
 
+  describe '#prefixes' do
+    describe "for exceptional input" do
+      it "returns empty string for empty string" do
+        expect(subject.prefixes('')).to be_empty
+      end
+
+      it "finds the prefix of a single letter (the letter itself)" do
+        expect(subject.prefixes('a')).to eq %w(a)
+      end
+    end
+
+    describe 'when case-insensitive' do
+      it 'finds all the prefixes of a string regardless of casing' do
+        %w(abstract Abstract).each do |string|
+          expect(subject.prefixes(string)).to eq %w(a ab abs)
+        end
+      end
+    end
+
+    describe 'when case-sensitive' do
+      let(:case_sensitive) { true }
+
+      it 'finds all the prefixes of a string, of the same casing' do
+        expect(subject.prefixes('abstract')).to eq %w(a ab abs)
+        expect(subject.prefixes('aBstract')).to eq %w(a)
+        expect(subject.prefixes('Abstract')).to be_empty
+      end
+    end
+  end
+
+
   describe '#inspect' do
-    specify { subject.inspect.should eq '#<Dictionary>' }
+    specify { expect(subject.inspect).to eq '#<Dictionary>' }
   end
 
   describe '#to_s' do
-    specify { subject.to_s.should eq '#<Dictionary>' }
+    specify { expect(subject.to_s).to eq '#<Dictionary>' }
   end
 
   describe '.from_file' do
@@ -139,15 +170,15 @@ describe Dictionary do
 
     shared_examples 'loaded dictionary' do
       it 'loads all words' do
-        subject.starting_with('a').size.should eq 5
-        subject.starting_with('b').size.should eq 4
-        subject.starting_with('y').size.should eq 1
-        subject.starting_with('z').size.should eq 3
+        expect(subject.starting_with('a').size).to eq 5
+        expect(subject.starting_with('b').size).to eq 4
+        expect(subject.starting_with('y').size).to eq 1
+        expect(subject.starting_with('z').size).to eq 3
       end
 
       it 'does not load nonexistent words' do
         ('c'..'x').each do |letter|
-          subject.starting_with(letter).should be_empty
+          expect(subject.starting_with(letter)).to be_empty
         end
       end
 

data/spec/ruby-dictionary/word_path_spec.rb

@@ -20,12 +20,12 @@ describe Dictionary::WordPath do
   describe '#leaf=' do
     it 'should set to false' do
       subject.leaf = false
-      subject.should_not be_leaf
+      expect(subject).not_to be_leaf
     end
 
     it 'should set to true' do
       subject.leaf = true
-      subject.should be_leaf
+      expect(subject).to be_leaf
     end
   end
 
@@ -37,18 +37,18 @@ describe Dictionary::WordPath do
 
       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' }
+        expect(word_path).to be_a Dictionary::WordPath
+        expect(word_path).to 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' }
+        expect(word_path).to be_a Dictionary::WordPath
+        expect(word_path).to 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
+        expect(subject.find('potable')).to be_nil
       end
     end
 
@@ -61,16 +61,16 @@ describe Dictionary::WordPath do
 
       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' }
+        expect(word_path).to be_a Dictionary::WordPath
+        expect(word_path).to 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
+        expect(subject.find('potat')).to be_nil
       end
 
       it 'does not find nonexistent word paths' do
-        subject.find('potat').should be_nil
+        expect(subject.find('potat')).to be_nil
       end
     end
   end
@@ -82,8 +82,8 @@ describe Dictionary::WordPath do
 
     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')
+        expect(subject.find('potato')).to be_a Dictionary::WordPath
+        expect(subject.find('poTAto')).to eq subject.find('potato')
       end
     end
 
@@ -91,8 +91,8 @@ describe Dictionary::WordPath 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
+        expect(subject.find('potato')).to be_a Dictionary::WordPath
+        expect(subject.find('poTAto')).to be_nil
       end
     end
   end
@@ -110,7 +110,7 @@ describe Dictionary::WordPath do
     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)
+        expect(word.suffixes).to eq %w(ato able ty)
       end
     end
 
@@ -119,7 +119,7 @@ describe Dictionary::WordPath do
 
       it 'finds all words with the given suffix' do
         word = subject.find('pot')
-        word.suffixes.should eq %w(ABle)
+        expect(word.suffixes).to eq %w(ABle)
       end
     end
   end

metadata

@@ -1,58 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: ruby-dictionary
 version: !ruby/object:Gem::Version
-  version: 1.1.0
-  prerelease: 
+  version: 1.1.1
 platform: ruby
 authors:
 - Matt Huggins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-27 00:00:00.000000000 Z
+date: 2014-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   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."
+description: |-
+  Dictionary class for ruby that allows for checking
+                           existence and finding words starting with a given
+                           prefix.
 email:
 - matt.huggins@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -73,33 +71,26 @@ files:
 - tasks/rspec.rake
 homepage: https://github.com/mhuggins/ruby-dictionary
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !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.25
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Simple dictionary class for checking existence of words
 test_files:
 - spec/fixtures/compressed_lined.txt.gz