passphrase 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f0c06ef87ec317d113d67632f44873e4c0b6c7f
-  data.tar.gz: c144b9ec21879b8717a5c3c3a0f5dc13be273542
+  metadata.gz: 4033cb9da1097b10de0c83644706f4b5ec71d04a
+  data.tar.gz: aba0d115c820f615f3f6124688f548b96f0fe9ba
 SHA512:
-  metadata.gz: f2711c0224023e76b00f2f1fea8358be40ee078edaa1891c3623f9803398cf4d2868261db067e0b9d0e072679cdb385e9b4809934325c06686de5d747c3110f1
-  data.tar.gz: a425a87a7134ffc3efa2262f208f278e0f941a33ea97f1eb35558fa8a68cba03661e139856e5d72a402ff49c6d50cd4ecf9eef950326b54270f8f7383160c07b
+  metadata.gz: 4cb595f7d1b1de7ee367a32817a6c5f9f1e568a12433303867f188192d7c8e4354c7ea3b4d3e40c5218c69592d3ff8b9a47b0fb81169c7263cea198f5bcc1b77
+  data.tar.gz: c2d8bb80517d152cfdf8f23e4c1c8bcb2f9ca52dfd01dee89b682b931940a849714219176919dade72afbdea97daaa7c9ba16bbbf6b4dea183081630d0352c5d

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 All notable changes to this project will be documented in this file. This
 project adheres to [Semantic Versioning](http://semver.org/).
 
+## UNRELEASED
+### Added
+- List available languages.
+- Added option `--languages|-l` to select a subset of languages.
+- Added a WordlistDatabase class.
+
 ## Version 1.1.0 - 2015-04-14
 ### Added
 - Added SHA256 checksum calculation to rake_helper.rb.

data/README.md

@@ -2,9 +2,10 @@
 Use Passphrase to generate a passphrase for SSH or GPG keys. For example, on
 the command-line, run
 
-    $ passphrase --num-words=4
-    dokusi uolgo allunga totalisa
-
+```bash
+$ passphrase --num-words=4
+dokusi uolgo allunga totalisa
+```
 or programmatically,
 
 ```ruby
@@ -12,12 +13,15 @@ require "passphrase"
 p = Passphrase::Passphrase.new(number_of_words: 4)
 passphrase = p.passphrase
 ```
+
 Passphrase also has the capability to generate passwords (indirectly).
 
 ## Installation
 The Passphrase command-line tool and library can be installed with
 
-    $ gem install passphrase
+```bash
+$ gem install passphrase
+```
 
 However, because the gem is cryptographically signed to prevent tampering, the
 preferred installation command should include the `--trust-policy` security
@@ -25,38 +29,63 @@ option, which causes the gem to be verified before being installed. To invoke
 this option, you must first add my public key `esumbar.pem` to your list of
 trusted certificates, as follows.
 
-    $ gem cert --add <(curl -Ls https://raw.githubusercontent.com/esumbar/passphrase/master/certs/esumbar.pem)
+```bash
+$ gem cert --add <(curl -Ls https://raw.githubusercontent.com/esumbar/passphrase/master/certs/esumbar.pem)
+```
 
 Finally, specify the appropriate security level when installing.
 
-    $ gem install passphrase --trust-policy MediumSecurity
+```bash
+$ gem install passphrase --trust-policy MediumSecurity
+```
 
-Using `MediumSecurity` rather than `HighSecurity` omits dependent gems, in
-this case `sqlite3`, which is not signed, from the verification process.
+Using `MediumSecurity` rather than `HighSecurity` omits dependent gems that
+are not signed from the verification process. Passphrase depends on the
+unsigned gem `sqlite3`.
 
 ## Basic usage
 ### Command-line tool
 
-    $ passphrase --help
-    Usage: passphrase [options]
-        -n, --num-words=NUM           Number of words in passphrase 3..10
-                                      (default: 5)
-        -p, --[no-]passwordize        Add one cap, one num, and one special char
-                                      (default: --no-passwordize)
-        -r, --[no-]random-org         Use RANDOM.ORG to generate random numbers
-                                      (default: --no-random-org)
-        -h, --help                    Show this message
-        -v, --version                 Show version
-
-    $ passphrase
-    sinmak termyne ismus affidavo recur
-
-    $ passphrase -n 4
-    apaisado vermouth seemag ebelik
-
-    $ passphrase -n 3 -p
-    pothvati alewives escatima
-    pothvati_alewiNes_e&cat5ma
+```bash
+$ passphrase --help
+Usage: passphrase [options]
+    -l, --languages=LANG1,...    Specify languages to use, none for a listing
+                                 (default: --languages=all)
+    -n, --num-words=NUM          Number of words in passphrase 3..10
+                                 (default: --num-words=5)
+    -p, --[no-]passwordize       Add one cap, one num, and one special char
+                                 (default: --no-passwordize)
+    -r, --[no-]random-org        Use RANDOM.ORG to generate random numbers
+                                 (default: --no-random-org)
+    -h, --help                   Show this message
+    -v, --version                Show version
+
+$ # generate a passphrase using default settings
+$ passphrase
+sinmak termyne ismus affidavo recur
+
+$ # generate a four-word passphrase
+$ passphrase -n4
+apaisado vermouth seemag ebelik
+
+$ # generate a passphrase using only English and Spanish words
+$ passphrase --languages=english,spanish
+fumada hearsay murcio phosphor azufroso
+
+$ # generate a three-word Polish passphrase and password
+$ passphrase -lp -n3 -p
+podejrza zmalala wypadkow
+8odej=za_Xmalala_wypadkow
+
+$ # list the available languages
+$ passphrase -l
+afrikaans
+croatian
+czech
+diceware
+english
+...
+```
 
 ### Ruby library
 
@@ -78,10 +107,15 @@ passphrase3 = p.generate.passphrase
 # generate an array of six-word passphrases
 passphrase_array = Array.new(100)
 Passphrase::Passphrase.new(number_of_words: 6) do |p|
-  passphrase_array.map! { |e| p.generate.passphrase }
+  passphrase_array.map! { |array_element| p.generate.passphrase }
 end
 
-# generate a password
+# generate a passphrase using only French and Italian words
+options = { number_of_words: 4, languages: %w( fr it ) }
+p = Passphrase::Passphrase.new(options)
+passphrase = p.passphrase
+
+# generate a password from a passphrase
 p = Passphrase::Passphrase.new(number_of_words: 3)
 passphrase = p.passphrase
 password   = passphrase.to_password
@@ -150,6 +184,13 @@ have the option of requesting random numbers from
 [RANDOM.ORG](http://www.random.org). However, because RANDOM.ORG depends on
 network access, it is susceptible to network problems, and is also slower.
 
+### Subset of languages
+By default, Passphrase randomly selects words from the collection of available
+languages. If desired, the selection can be limited to a subset of languages.
+This can be done on the command-line and in code by supplying a list of
+language names or abbreviations. A minimal abbreviation uses the first one or
+two letters of a language name, just enough to avoid ambiguity.
+
 ### Passwords
 A typical passphrase will not satisfy password policies that require the use
 of upper case letters, numbers, and special characters (~, !, and the like).
@@ -173,13 +214,17 @@ compliment of 7776 entries.
 To run the command-line tool within the repository directory, try `ruby -Ilib
 bin/passphrase`. You can also experiment with the library in irb. For example,
 
-    $ irb -Ilib -rpassphrase
-    >> p = Passphrase::Passphrase.new(number_of_words: 3)
-    => {:passphrase=>"jazzy vannier viscount", :number_of_words=>3, ... }
-    >> p.passphrase
-    => "jazzy vannier viscount"
-    >> p.passphrase.to_password
-    => "jazz{_2annier_vBscount"
+```bash
+$ irb -Ilib -rpassphrase
+>> p = Passphrase::Passphrase.new(number_of_words: 3)
+=> {:passphrase=>"jazzy vannier viscount", :number_of_words=>3, ... }
+>> p.passphrase
+=> "jazzy vannier viscount"
+>> p.passphrase.to_password
+=> "jazz{_2annier_vBscount"
+>> p = Passphrase::Passphrase.new(languages: ["e", "fr"])
+=> {:passphrase=>"obstrua lamparos orgy forerez deduce", ... }
+```
 
 Run the tests with `rake spec`.
 

data/lib/passphrase.rb

@@ -2,6 +2,7 @@ require "passphrase/default"
 require "passphrase/passphrase"
 require "passphrase/version"
 
+# The enclosing namespace for the Passphrase library.
 module Passphrase
   autoload(:CLI, "passphrase/CLI")
 end

data/lib/passphrase/CLI.rb

@@ -1,4 +1,5 @@
 require "optparse"
+require "passphrase/wordlist_database"
 
 module Passphrase
   # The CLI class encapsulates a simple command line interface to the
@@ -38,13 +39,18 @@ module Passphrase
       default_random_org = Default.options[:use_random_org] ? "--random-org" : "--no-random-org"
       default_number_range = Default.number_range
 
-      parser = OptionParser.new do |opts|
+      parser = OptionParser.new(nil, 28, " " * 4) do |opts|
         opts.banner = "Usage: passphrase [options]"
+        opts.on(:OPTIONAL, "-l", "--languages=LANG1,...", Array,
+          "Specify languages to use, none for a listing",
+          "(default: --languages=all)") do |l|
+            options[:languages] = (l || [])
+        end
         opts.on(:REQUIRED, "-n NUM", "--num-words=NUM", Integer,
           "Number of words in passphrase #{default_number_range}",
-          "(default: #{default_number_of_words})") do |n|
+          "(default: --num-words=#{default_number_of_words})") do |n|
             options[:number_of_words] = n
-          end
+        end
         opts.on(:NONE, "-p", "--[no-]passwordize",
           "Add one cap, one num, and one special char",
           "(default: #{default_passwordize})") do |p|
@@ -67,15 +73,15 @@ module Passphrase
 
       begin
         parser.parse!(args)
+        display_languages(options)
         validate_number_of_words(options)
         passphrase = Passphrase.new(options).passphrase
-        puts passphrase
-        puts passphrase.to_password if options[:passwordize]
+        print_out(passphrase, options)
       rescue OptionParser::InvalidOption => e
         handle_error(e)
       rescue OptionParser::MissingArgument => e
         handle_error(e)
-      # gracefully handle exit(0) from --help and --version options
+      # Gracefully handle exit(0) from --help, --version, and --language options
       rescue SystemExit => e
         exit(e.status)
       rescue Exception => e
@@ -83,20 +89,35 @@ module Passphrase
       end
     end
 
+    def self.display_languages(options)
+      if options[:languages].empty?
+        puts WordlistDatabase.connect.from(:languages).all
+        exit(0)
+      end
+    end
+
     def self.validate_number_of_words(options)
       number_of_words = options[:number_of_words]
       unless Default.number_range.include?(number_of_words)
-        raise "number of words out of range #{Default.number_range}"
+        raise "Number of words out of range #{Default.number_range}"
       end
     end
 
+    def self.print_out(passphrase, options)
+      puts passphrase
+      puts passphrase.to_password if options[:passwordize]
+    end
+
     def self.handle_error(error)
       STDERR.puts "ERROR: #{error.message}"
       exit(1)
     end
 
     class << self
-      private :validate_number_of_words, :handle_error
+      private :display_languages
+      private :validate_number_of_words
+      private :print_out
+      private :handle_error
     end
   end
 end

data/lib/passphrase/default.rb

@@ -1,4 +1,7 @@
 module Passphrase
+  # Class instance variables in this class define default values for
+  # {Passphrase} options and the range for the number of words that can be
+  # specified for a passphrase on the command-line.
   class Default
     class << self
       # @return [Hash] the default options that the command line interface
@@ -9,7 +12,12 @@ module Passphrase
       attr_reader :number_range
     end
 
-    @options = { number_of_words: 5, passwordize: nil, use_random_org: nil }
+    @options = {
+      languages: ["all"],
+      number_of_words: 5,
+      passwordize: nil,
+      use_random_org: nil
+    }
     @number_range = (3..10)
   end
 end

data/lib/passphrase/diceware_method.rb

@@ -1,7 +1,5 @@
-require "sqlite3"
 require "passphrase/diceware_random"
-require "passphrase/language_query"
-require "passphrase/word_query"
+require "passphrase/wordlist_database"
 
 module Passphrase
   # This class implements the Diceware Method for generating a passphrase. It
@@ -20,8 +18,9 @@ module Passphrase
     def initialize(options)
       @number_of_words = options[:number_of_words]
       @random = DicewareRandom.new(options[:use_random_org])
-      setup_database
-      setup_queries
+      db = WordlistDatabase.connect
+      @languages = db.from(:languages).only(options[:languages])
+      @words = db.from(:words)
     end
 
     # Runs the Diceware method and returns its result to the calling
@@ -37,18 +36,6 @@ module Passphrase
 
     private
 
-    def setup_database
-      wordlist_file = "wordlist/words.sqlite3"
-      wordlist_path = File.join(File.dirname(__FILE__), wordlist_file)
-      raise "Wordlist database not found" unless File.exist?(wordlist_path)
-      @db = SQLite3::Database.new(wordlist_path, readonly: true)
-    end
-
-    def setup_queries
-      @languages = LanguageQuery.new(@db)
-      @words = WordQuery.new(@db)
-    end
-
     def get_random_languages
       @random_languages = @random.indices(@number_of_words, @languages.count)
       @random_languages.map! { |index| @languages[index] }

data/lib/passphrase/diceware_random.rb

@@ -65,6 +65,7 @@ module Passphrase
     def setup_remote_generator
       self.class.class_eval do
         def generate_random_numbers(count, maximum, minimum=0)
+          return Array.new(count, maximum) if maximum == minimum
           # Check quota before proceeding and thereafter every 1000 uses to
           # comply with random.org guidelines.
           check_random_org_quota if self.class.random_org_requests % 1000 == 0
@@ -92,7 +93,7 @@ module Passphrase
           open("#{@random_org_uri}#{query}") do |data|
             quota = data.gets.chomp.to_i
             over_quota_message = "RANDOM.ORG over quota, try again in 10 minutes"
-            raise "ERROR: #{over_quota_message}" if quota < 0
+            raise "#{over_quota_message}" if quota < 0
           end
         end
 
@@ -104,6 +105,7 @@ module Passphrase
     def setup_local_generator
       self.class.class_eval do
         def generate_random_numbers(count, maximum, minimum=0)
+          return Array.new(count, maximum) if maximum == minimum
           max = maximum - minimum + 1
           offset = minimum
           # array_of_random_numbers

data/lib/passphrase/passphrase_string.rb

@@ -1,5 +1,5 @@
 module Passphrase
-  # This subclass of String implements the {#passwordize} instance method for
+  # This subclass of String implements the {#to_password} instance method for
   # substituting a capital letter, number, and special character into a
   # passphrase.
   class PassphraseString < String

data/lib/passphrase/version.rb

@@ -1,5 +1,5 @@
 module Passphrase
   # Version numbers are bumped according to {http://semver.org Semantic
   # Versioning}.
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/lib/passphrase/wordlist_database.rb

@@ -0,0 +1,103 @@
+require "sqlite3"
+
+module Passphrase
+  # This class encapsulates the {#count} and {#[]} queries against the
+  # "languages" table in the "words" SQLite 3 database. It also provides the
+  # {#only} method which allows a subset of languages to be specified.
+  class Language
+    def initialize(db)
+      @languages = []
+      sql = "SELECT language FROM languages"
+      db.execute(sql).each { |lang| @languages << lang.first }
+    end
+    
+    # @return [Integer] the number of rows in the languages table
+    def count
+      @languages.size
+    end
+
+    # @param index [Integer] selects a specific row in the languages table
+    # @return [String] the language corresponding to the given index
+    def [](index)
+      @languages[index]
+    end
+
+    # @return [Array] all rows in the languages table
+    def all
+      @languages
+    end
+
+    # @param language_list [Array] restrict languages to those in the list
+    # @return [self] to allow chaining methods
+    def only(language_list)
+      return self if /^all$/ =~ language_list.first
+      validate(language_list)
+      @languages.keep_if do |language|
+        language_list.any? { |l| language.match("^#{l}") }
+      end
+      self
+    end
+
+    private
+
+    # Make sure that each language specification matches at least one
+    # language.
+    def validate(language_list)
+      language_list.each do |l|
+        matches_language = @languages.any? { |language| language.match("^#{l}") }
+        raise "No language match for #{l}" unless matches_language
+      end
+    end
+  end
+  # This class encapsulates the {#where} query against the "words" table in
+  # the "words" SQLite 3 database. The filter parameter must be a hash that
+  # specifies a language and sequence of die rolls.
+  # @example
+  #   {language: "afrikaans", die_rolls: "11111"}
+  class Word
+    def initialize(db)
+      @db = db
+    end
+
+    # @param filter [Hash] specifies the language/die_roll combination
+    # @return [String] a string of space-separated words from the wordlist
+    def where(filter)
+      sql = "SELECT words " + 
+            "FROM words " + 
+            "WHERE language = :language AND die_rolls = :die_rolls"
+      @db.get_first_value(sql, filter)
+    end
+  end
+  # This class encapsulates the Diceware wordlist database file and dispatches
+  # one of two table query objects via the {#from} method.
+  class WordlistDatabase
+    # A "connect" method seems more natural than "new" when connecting to a
+    # database.
+    def self.connect
+      new
+    end
+
+    def initialize
+      wordlist_file = "wordlist/words.sqlite3"
+      wordlist_path = File.join(File.dirname(__FILE__), wordlist_file)
+      raise "Wordlist database file not found" unless File.exist?(wordlist_path)
+      @db = SQLite3::Database.new(wordlist_path, readonly: true)
+    end
+
+    # @param table [Symbol] the table name
+    # @return [Language] if the "languages" table is specified
+    # @return [Word] if the "words" table is specified
+    def from(table)
+      case table
+      when :languages
+        Language.new(@db)
+      when :words
+        Word.new(@db)
+      else
+        raise "Unknown table #{table}"
+      end
+    end
+
+    alias [] from
+  end
+end

data/spec/passphrase/cli_spec.rb

@@ -16,14 +16,26 @@ module Passphrase
       expect(CLI).to respond_to(:parse).with(1).argument
     end
 
+    it "does not respond to class method display_languages() (private)" do
+      expect(CLI).not_to respond_to(:display_languages)
+    end
+
     it "does not respond to class method validate_number_of_words() (private)" do
       expect(CLI).not_to respond_to(:validate_number_of_words)
     end
 
+    it "does not respond to class method print_out() (private)" do
+      expect(CLI).not_to respond_to(:print_out)
+    end
+
     it "does not respond to class method handle_error() (private)" do
       expect(CLI).not_to respond_to(:handle_error)
     end
 
+    it "exits when option -l is supplied" do
+      expect { CLI.parse(["-l"]) }.to raise_error(SystemExit)
+    end
+
     it "does not emit an error when option -n 3 is supplied" do
       expect(CLI).not_to receive(:handle_error)
       CLI.parse(["-n", "3"])

data/spec/passphrase/diceware_method_spec.rb

@@ -6,25 +6,15 @@ module Passphrase
       expect(DicewareMethod).to respond_to(:run).with(1).argument
     end
 
-    context "initialized with given options" do
+    context "initialized with default options" do
       before do
-        @number_of_words = 5
-        options = { number_of_words: @number_of_words, use_random_org: nil }
-        @diceware = DicewareMethod.new(options)
+        @diceware = DicewareMethod.new(Default.options)
       end
       
       it "responds to the run() method with no arguments" do
         expect(@diceware).to respond_to(:run)
       end
 
-      it "does not respond to the setup_database() method (private)" do
-        expect(@diceware).not_to respond_to(:setup_database)
-      end
-
-      it "does not respond to the setup_queries() method (private)" do
-        expect(@diceware).not_to respond_to(:setup_queries)
-      end
-
       it "does not respond to the get_random_languages() method (private)" do
         expect(@diceware).not_to respond_to(:get_random_languages)
       end
@@ -50,9 +40,9 @@ module Passphrase
           )
         end
 
-        it "each array contains :number_of_words elements" do
+        it "each array contains the default number of words elements" do
           @result.each do |result|
-            expect(result.size).to eq(@number_of_words)
+            expect(result.size).to eq(Default.options[:number_of_words])
           end
         end
 

data/spec/passphrase/diceware_random_spec.rb

@@ -52,6 +52,24 @@ module Passphrase
       end
     end
 
+    describe "#indices(4, 1)" do
+      before do
+        @result = @random.indices(4, 1)
+      end
+
+      it "returns an array" do
+        expect(@result).to be_an_instance_of(Array)
+      end
+
+      it "of size 4" do
+        expect(@result.size).to eq(4)
+      end
+
+      it "where each element is zero" do
+        expect(@result).to all eq(0)
+      end
+    end
+
     describe "#die_rolls(6)" do
       before do
         @result = @random.die_rolls(6)
@@ -97,7 +115,7 @@ module Passphrase
         @random = DicewareRandom.new(true)
       end
 
-      it "increments the random.org request count on indices()" do
+      it "increments the RANDOM.ORG request count on indices()" do
         expect {
           @random.indices(4, 15)
           }.to change(DicewareRandom, :random_org_requests).by(1)

data/spec/passphrase/wordlist_database_spec.rb

@@ -0,0 +1,147 @@
+require "passphrase"
+
+module Passphrase
+  RSpec.describe WordlistDatabase, "Diceware wordlist database class" do
+    before do
+      @db = WordlistDatabase.connect
+    end
+
+    describe "#from(:languages)" do
+      it "returns a Language object" do
+        expect(@db.from(:languages)).to be_an_instance_of(Language)
+      end
+    end
+
+    describe "#[:languages]" do
+      it "returns a Language object" do
+        expect(@db[:languages]).to be_an_instance_of(Language)
+      end
+    end
+
+    describe "#from(:words)" do
+      it "returns a Word object" do
+        expect(@db.from(:words)).to be_an_instance_of(Word)
+      end
+    end
+
+    describe "#[:words]" do
+      it "returns a Word object" do
+        expect(@db[:words]).to be_an_instance_of(Word)
+      end
+    end
+
+    describe "#from(:nonexistant)" do
+      it "raises an error" do
+        expect { @db.from(:nonexistant) }.to raise_error("Unknown table nonexistant")
+      end
+    end
+  end
+
+  RSpec.describe Word, "queries the words table in a valid wordlist database" do
+    before do
+      @words = WordlistDatabase.connect.from(:words)
+    end
+
+    it "responds to the where() method with one argument" do
+      expect(@words).to respond_to(:where).with(1).argument
+    end
+
+    describe "#where([Hash])" do
+      before do
+        @selection = @words.where(language: "afrikaans", die_rolls: "11111")
+      end
+
+      it "returns a string" do
+        expect(@selection).to be_an_instance_of(String)
+      end
+
+      it "that is not empty" do
+        expect(@selection).not_to be_empty
+      end
+    end
+  end
+
+  RSpec.describe Language, "queries the languages table in a valid wordlist database" do
+    before do
+      @languages = WordlistDatabase.connect.from(:languages)
+    end
+
+    it "responds to the count() method with no arguments" do
+      expect(@languages).to respond_to(:count).with(0).arguments
+    end
+
+    it "responds to the []() method with one argument" do
+      expect(@languages).to respond_to(:[]).with(1).argument
+    end
+
+    it "responds to the all() method with no arguments" do
+      expect(@languages).to respond_to(:all).with(0).arguments
+    end
+
+    it "responds to the only() method with one argument" do
+      expect(@languages).to respond_to(:only).with(1).argument
+    end
+
+    it "does not respond to the validate() method (private)" do
+      expect(@languages).not_to respond_to(:validate)
+    end
+
+    describe "#count" do
+      it "returns 15" do
+        expect(@languages.count).to eq(15)
+      end
+    end
+
+    describe "#[](0)" do
+      before do
+        @language = @languages[0]
+      end
+
+      it "returns a string" do
+        expect(@language).to be_an_instance_of(String)
+      end
+
+      it "that is not empty" do
+        expect(@language).not_to be_empty
+      end
+    end
+
+    describe "#all" do
+      before do
+        @result = @languages.all
+      end
+
+      it "returns an array" do
+        expect(@result).to be_an_instance_of(Array)
+      end
+
+      it "with 15 elements" do
+        expect(@result.size).to eq(15)
+      end
+
+      it "of all strings" do
+        expect(@result).to all be_an_instance_of(String)
+      end
+    end
+
+    describe "#only([\"e\", \"fr\"])" do
+      before do
+        @languages.only(["e", "fr"])
+      end
+
+      it "produces a count of 2" do
+        expect(@languages.count).to eq(2)
+      end
+
+      it "returns only english and french" do
+        expect(@languages.all).to eq(%w( english french ))
+      end
+    end
+
+    describe "#only([\"zz\"])" do
+      it "raises an error" do
+        expect { @languages.only(["zz"]) }.to raise_error("No language match for zz")
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: passphrase
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Edmund Sumbar
@@ -30,7 +30,7 @@ cert_chain:
   aoKZhUfRmAZDUgzW4PMtMxO34fQDbDYevBzMcxmkHNDs87ROMOuPLWJGLcKpgGwJ
   TxzUtBfb7E+Qa/wyo0Ws7A==
   -----END CERTIFICATE-----
-date: 2015-04-15 00:00:00.000000000 Z
+date: 2015-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3
@@ -137,19 +137,17 @@ files:
 - lib/passphrase/default.rb
 - lib/passphrase/diceware_method.rb
 - lib/passphrase/diceware_random.rb
-- lib/passphrase/language_query.rb
 - lib/passphrase/passphrase.rb
 - lib/passphrase/passphrase_string.rb
 - lib/passphrase/version.rb
-- lib/passphrase/word_query.rb
 - lib/passphrase/wordlist/words.sqlite3
+- lib/passphrase/wordlist_database.rb
 - spec/passphrase/cli_spec.rb
 - spec/passphrase/diceware_method_spec.rb
 - spec/passphrase/diceware_random_spec.rb
-- spec/passphrase/language_query_spec.rb
 - spec/passphrase/passphrase_spec.rb
 - spec/passphrase/passphrase_string_spec.rb
-- spec/passphrase/word_query_spec.rb
+- spec/passphrase/wordlist_database_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/esumbar/passphrase
 licenses:

metadata.gz.sig

@@ -1 +1 @@
-�S������@��0J����۔t��D_���_��h|2@N
���I��扷��Xܟ����t2}P���aD�p����-Yid��F��,��4����$-k��S�p��r�N�7d�d�}0�]F��f�������m�.�R����d�[�fu���s���Fo�p�im�>����*�2�B�G��x�
6���\���#-}��J���"y#@��>.]��ц!N�J��D�q���<ۢ'��N+���1���մ��
+-��1�,x�8X:����h6��j;��&R�SLY<�Li`p�����q���'�l��d�9/�S�`�O!N]&_ɩ�����{>C��?�$��ʎ�����lu_�R[][�~4r%�Rr��g=@��x�]f/&%����8�S0F�O|��X�Z$�c�UC��6��Mh��
�:gz��ê��������i.��0ë2Xx���0�IĹ�~I4-ٮ�+���b�%4���>�oc8G�

data/lib/passphrase/language_query.rb

@@ -1,26 +0,0 @@
-module Passphrase
-  # This class encapsulates the {#count} and {#[]} queries against the
-  # "languages" table in the "words" SQLite 3 database.
-  class LanguageQuery
-    def initialize(db)
-      @db = db
-    end
-    
-    # @return [Integer] the number of rows in the languages table
-    def count
-      sql = "SELECT COUNT(*) AS count FROM languages"
-      @db.get_first_value(sql)
-    end
-
-    # @param index [Integer] selects a specific row in the languages table
-    # @return [String] the language corresponding to the given index
-    def [](index)
-      sql = "SELECT language FROM languages"
-      unless @languages
-        @languages = []
-        @db.execute(sql).each { |lang| @languages << lang.first }
-      end
-      @languages[index]
-    end
-  end
-end

data/lib/passphrase/word_query.rb

@@ -1,21 +0,0 @@
-module Passphrase
-  # This class encapsulates the {#where} query against the "words" table in
-  # the "words" SQLite 3 database. The filter parameter must be a hash that
-  # specifies a language and sequence of die rolls.
-  # @example
-  #   {language: "afrikaans", die_rolls: "11111"}
-  class WordQuery
-    def initialize(db)
-      @db = db
-    end
-
-    # @param filter [Hash] specifies the language/die_roll combination
-    # @return [String] the selected words from the wordlist
-    def where(filter)
-      sql = "SELECT words " + 
-            "FROM words " + 
-            "WHERE language = :language AND die_rolls = :die_rolls"
-      @db.get_first_value(sql, filter)
-    end
-  end
-end

data/spec/passphrase/language_query_spec.rb

@@ -1,48 +0,0 @@
-require "passphrase"
-
-module Passphrase
-  RSpec.describe LanguageQuery, "queries the languages table in a valid wordlist database" do
-    before do
-      wordlist_file = "../../lib/passphrase/wordlist/words.sqlite3"
-      wordlist_path = File.join(File.dirname(__FILE__), wordlist_file)
-      db = SQLite3::Database.new(wordlist_path, readonly: true)
-      @languages = LanguageQuery.new(db)
-    end
-
-    it "responds to the count() method with no arguments" do
-      expect(@languages).to respond_to(:count).with(0).arguments
-    end
-
-    it "responds to the []() method with one argument" do
-      expect(@languages).to respond_to(:[]).with(1).argument
-    end
-
-    context "#count" do
-      before do
-        @count = @languages.count
-      end
-
-      it "returns an integer" do
-        expect(@count).to be_an_instance_of(Fixnum)
-      end
-
-      it "greater than zero" do
-        expect(@count).to be > 0
-      end
-    end
-
-    context "#[](0)" do
-      before do
-        @language = @languages[0]
-      end
-
-      it "returns a string" do
-        expect(@language).to be_an_instance_of(String)
-      end
-
-      it "that is not empty" do
-        expect(@language).not_to be_empty
-      end
-    end
-  end
-end

data/spec/passphrase/word_query_spec.rb

@@ -1,30 +0,0 @@
-require "passphrase"
-
-module Passphrase
-  RSpec.describe WordQuery, "queries the words table in a valid wordlist database" do
-    before do
-      wordlist_file = "../../lib/passphrase/wordlist/words.sqlite3"
-      wordlist_path = File.join(File.dirname(__FILE__), wordlist_file)
-      db = SQLite3::Database.new(wordlist_path, readonly: true)
-      @words = WordQuery.new(db)
-    end
-
-    it "responds to the where() method with one argument" do
-      expect(@words).to respond_to(:where).with(1).argument
-    end
-
-    context "#where([Hash])" do
-      before do
-        @selection = @words.where(language: "afrikaans", die_rolls: "11111")
-      end
-
-      it "returns a string" do
-        expect(@selection).to be_an_instance_of(String)
-      end
-
-      it "that is not empty" do
-        expect(@selection).not_to be_empty
-      end
-    end
-  end
-end