passphrase 0.1.0 → 1.0.0

data/lib/passphrase/language_query.rb

@@ -0,0 +1,26 @@
+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/passphrase.rb

@@ -0,0 +1,80 @@
+module Passphrase
+  # This is the main class of the Passphrase library for generating
+  # passphrases. It's initialized with a two-element hash that specifies the
+  # number of words in the resulting passphrase and a flag to use the
+  # RANDOM.ORG site as a source of random numbers.
+  # @example
+  #   require "passphrase"
+  #   p = Passphrase::Passphrase.new(number_of_words: 4, use_random_org: nil)
+  #   puts p.generate
+  class Passphrase
+
+    # @return [String] the passphrase string
+    attr_reader :passphrase
+
+    # @param options [Hash] characteristics for a new Passphrase object
+    # @yieldparam obj [self] the Passphrase object
+    def initialize(options={})
+      @options = Default.options.merge(options)
+      @passphrase = ""
+      @languages = []
+      @die_rolls = []
+      @words = []
+      yield self if block_given?
+    end
+
+    # Invokes the Diceware method by running {DicewareMethod.run}. The three
+    # resulting arrays are accumulated into instance variables. The words
+    # array is formatted into a single passphrase string and stored in another
+    # instance variable. The method returns itself to allow method chaining.
+    # @return [self] a Passphrase object
+    def generate
+      @languages, @die_rolls, @words = DicewareMethod.run(@options)
+      @passphrase = @words.join(" ")
+      self
+    end
+
+    # This virtual attribute accessor returns the number of words in the
+    # generated passphrase.
+    # @return [Integer] the number of words in the passphrase
+    def number_of_words
+      @words.size
+    end
+
+    # A predicate method that returns true if the Passphrase object is
+    # initialized to use RANDOM.ORG
+    # @return [Boolean] returns true of RANDOM.ORG is being used
+    def using_random_org?
+      @options[:use_random_org]
+    end
+
+    # String representation of a Passphrase object
+    # @return [String] the passphrase string
+    def to_s
+      @passphrase
+    end
+
+    # Returns details for the Passphrase object as a hash.
+    # @return [Hash] the details of a Passphrase object
+    def inspect
+      {
+        passphrase: @passphrase,
+        number_of_words: @words.size,
+        word_origins: word_origins
+      }
+    end
+
+    private
+
+    def word_origins
+      word_origins = {}
+      @words.each_index do |index|
+        word_origins[@words[index]] = {
+          language: @languages[index],
+          die_rolls: @die_rolls[index]
+        }
+      end
+      word_origins
+    end
+  end
+end

data/lib/passphrase/version.rb

@@ -1,14 +1,5 @@
-#! /usr/bin/env ruby
-
 module Passphrase
-  module Version
-
-    # rubygems rational versioning policy
-    # http://docs.rubygems.org/read/chapter/7
-    MAJOR = 0
-    MINOR = 1
-    BUILD = 0
-
-    STRING = [MAJOR, MINOR, BUILD].compact.join('.')
-  end
+  # Version numbers are bumped according to {http://semver.org Semantic
+  # Versioning}.
+  VERSION = "1.0.0"
 end

data/lib/passphrase/word_query.rb

@@ -0,0 +1,21 @@
+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/cli_spec.rb

@@ -0,0 +1,47 @@
+require "passphrase"
+require "optparse"
+
+module Passphrase
+  RSpec.describe CLI, "implements the command line interface" do
+    it "responds to class method parse() with one argument" do
+      expect(CLI).to respond_to(:parse).with(1).argument
+    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 handle_error() (private)" do
+      expect(CLI).not_to respond_to(:handle_error)
+    end
+
+    it "emits an error when an invalid option is supplied" do
+      # For some reason, :handle_error doesn't need to be stubbed
+      expect(CLI).to receive(:handle_error)
+        .with(kind_of(OptionParser::InvalidOption))
+      bad_option = ["-x"]
+      CLI.parse(bad_option)
+    end
+
+    it "emits an error when a mandatory argument is missing" do
+      # For some reason, :handle_error doesn't need to be stubbed
+      expect(CLI).to receive(:handle_error).twice
+        .with(kind_of(OptionParser::MissingArgument))
+      [["-n"], ["--num-words"]].each { |bad_option| CLI.parse(bad_option) }
+    end
+
+    it "emits an error when the number of words is out of range" do
+      under_range = (Default.number_range.min - 1).to_s
+      over_range = (Default.number_range.max + 1).to_s
+      # For some reason, :handle_error doesn't need to be stubbed
+      expect(CLI).to receive(:handle_error).exactly(4).times
+        .with(kind_of(RuntimeError))
+      ["-n", "--num-words"].each do |opt|
+        [under_range, over_range].each do |arg|
+          bad_option = [opt, arg]
+          CLI.parse(bad_option)
+        end
+      end
+    end
+  end
+end

data/spec/passphrase/diceware_method_spec.rb

@@ -0,0 +1,61 @@
+require "passphrase"
+
+module Passphrase
+  RSpec.describe DicewareMethod, "implements the Diceware method" do
+    it "responds to the class method run() with one argument" do
+      expect(DicewareMethod).to respond_to(:run).with(1).argument
+    end
+
+    context "initialized with given options" do
+      before do
+        @number_of_words = 5
+        options = { number_of_words: @number_of_words, use_random_org: nil }
+        @diceware = DicewareMethod.new(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
+
+      it "does not respond to the get_random_random_die_rolls() method (private)" do
+        expect(@diceware).not_to respond_to(:get_random_random_die_rolls)
+      end
+
+      it "does not respond to the select_words_from_wordlist() method (private)" do
+        expect(@diceware).not_to respond_to(:select_words_from_wordlist)
+      end
+
+      describe "#run" do
+        before do
+          @result = @diceware.run
+        end
+
+        it "returns an array of three arrays" do
+          expect(@result).to contain_exactly(
+            an_instance_of(Array),
+            an_instance_of(Array),
+            an_instance_of(Array)
+          )
+        end
+
+        it "each array is of size given by the number of words specified" do
+          @result.each do |result|
+            expect(result.size).to eq(@number_of_words)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/passphrase/diceware_random_spec.rb

@@ -0,0 +1,124 @@
+require "passphrase"
+
+module Passphrase
+  RSpec.shared_examples "DicewareRandom object" do
+    it "responds to the indices() method with 2 args" do
+      expect(@random).to respond_to(:indices).with(2).arguments
+    end
+
+    it "responds to the die_rolls() method with 1 arg" do
+      expect(@random).to respond_to(:die_rolls).with(1).arguments
+    end
+
+    it "does not respond to the setup_remote_generator() method (private)" do
+      expect(@random).not_to respond_to(:setup_remote_generator)
+    end
+
+    it "does not respond to the setup_local_generator() method (private)" do
+      expect(@random).not_to respond_to(:setup_local_generator)
+    end
+
+    it "does not respond to the generate_random_numbers() method (private)" do
+      expect(@random).not_to respond_to(:generate_random_numbers)
+    end
+
+    it "does not respond to the group_die_rolls() method (private)" do
+      expect(@random).not_to respond_to(:group_die_rolls)
+    end
+
+    describe "#indices(4, 15)" do
+      before do
+        @result = @random.indices(4, 15)
+      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 "all Fixnum items" do
+        expect(@result).to all be_an_instance_of(Fixnum)
+      end
+
+      it "each one in the range 0...15" do
+        expect(@result).to all be_between(0, 14)
+      end
+    end
+
+    describe "#die_rolls(6)" do
+      before do
+        @result = @random.die_rolls(6)
+      end
+
+      it "returns an array" do
+        expect(@result).to be_an_instance_of(Array)
+      end
+
+      it "of size 6" do
+        expect(@result.size).to eq(6)
+      end
+
+      it "all String items" do
+        expect(@result).to all be_an_instance_of(String)
+      end
+
+      it "each one five characters long" do
+        expect(@result.map(&:length)).to all eq(5)
+      end
+
+      it "that match the pattern /^[123456]+$/" do
+        expect(@result).to all match(/^[123456]+$/)
+      end
+    end
+  end
+
+  RSpec.describe DicewareRandom, "generates and formats arrays of random numbers" do
+    it "responds to the attribute reader method random_org_requests()" do
+      expect(DicewareRandom).to respond_to(:random_org_requests)
+    end
+
+    context "initialized by default to use the local Ruby random number generator" do
+      before do
+        @random = DicewareRandom.new
+      end
+      
+      include_examples "DicewareRandom object"
+    end
+
+    context "initialized to use random numbers from RANDOM.ORG" do
+      before do
+        @random = DicewareRandom.new(:use_random_org)
+      end
+
+      it "initially has a zero random.org request count" do
+        expect(DicewareRandom.random_org_requests).to eq(0)
+      end
+
+      it "increments the random.org request count on indices()" do
+        expect {
+          @random.indices(4, 15)
+          }.to change(DicewareRandom, :random_org_requests).by(1)
+      end
+
+      it "increments the RANDOM.ORG request count on die_rolls()" do
+        expect {
+          @random.die_rolls(4)
+          }.to change(DicewareRandom, :random_org_requests).by(1)
+      end
+
+      it "does not respond to the check_random_org_quota() method (private)" do
+        expect(@random).not_to respond_to(:check_random_org_quota)
+      end
+
+      it "raises an exception when a network error occurs (e.g. wrong address)" do
+        @random.instance_eval { @random_org_uri = "https://www.randomx.org" }
+        expect { @random.indices(4, 15) }.to raise_error
+      end
+        
+      include_examples "DicewareRandom object"
+    end
+  end
+end

data/spec/passphrase/language_query_spec.rb

@@ -0,0 +1,48 @@
+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/passphrase_spec.rb

@@ -0,0 +1,118 @@
+require "passphrase"
+
+module Passphrase
+  RSpec.describe Passphrase, "for generating passphrase objects" do
+    it "yields itself during instantiation" do
+      expect { |b| Passphrase.new(Default.options, &b) }.to yield_with_args(Passphrase)
+    end
+
+    # Dependence on RANDOM.ORG only affects the DicewareRandom class.
+    # Therefore, only need to test the case where RANDOM.ORG is not used.
+    context "initialized to generate a passphrase with 1 word, not using RANDOM.ORG" do
+      before do
+        @passphrase = Passphrase.new(number_of_words: 1, use_random_org: nil)
+      end
+
+      it "responds to the generate() method with zero arguments" do
+        expect(@passphrase).to respond_to(:generate).with(0).arguments
+      end
+
+      it "responds to the to_s() method" do
+        expect(@passphrase).to respond_to(:to_s)
+      end
+
+      it "responds to the inspect() method with zero arguments" do
+        expect(@passphrase).to respond_to(:inspect).with(0).arguments
+      end
+
+      it "responds to attribute reader method passphrase()" do
+        expect(@passphrase).to respond_to(:passphrase)
+      end
+
+      it "responds to predicate method using_random_org?()" do
+        expect(@passphrase).to respond_to(:using_random_org?)
+      end
+
+      it "responds to virtual attribute reader method number_of_words()" do
+        expect(@passphrase).to respond_to(:number_of_words).with(0).arguments
+      end
+
+      it "does not respond to the word_origins() method (private)" do
+        expect(@passphrase).not_to respond_to(:word_origins)
+      end
+
+      it "initially contains an empty passphrase string" do
+        expect(@passphrase.passphrase).to be_empty
+      end
+
+      it "initially contains zero words" do
+        expect(@passphrase.number_of_words).to eq(0)
+      end
+
+      it "should not be using RANDOM.ORG" do
+        expect(@passphrase).not_to be_using_random_org
+      end
+
+      context "after executing the generate() method" do
+        before do
+          dwr = [["language"], ["11111"], ["passphrase"]]
+          allow(DicewareMethod).to receive(:run).and_return(dwr)
+          @result = @passphrase.generate
+        end
+
+        it "returns itself" do
+          expect(@result).to equal(@passphrase)
+        end
+
+        it "contains the passphrase string" do
+          expect(@result.passphrase).to eq("passphrase")
+        end
+
+        it "contains a number of words equal to one" do
+          expect(@result.number_of_words).to eq(1)
+        end
+
+        it "returns the passphrase when printed" do
+          sio = StringIO.new("")
+          $stdout = sio
+          expect { puts @result }.to change { sio.string.chomp }
+            .from("").to(@result.passphrase)
+        end
+
+        it "can be inspected" do
+          expect(@result.inspect).to match(
+            passphrase: "passphrase",
+            number_of_words: 1,
+            word_origins: { "passphrase" => {
+              language: "language",
+              die_rolls: "11111"
+              }
+            }
+          )
+        end
+      end
+    end
+
+    context "initialized to use RANDOM.ORG" do
+      it "the predicate method should confirm it is using RANDOM.ORG" do
+        passphrase = Passphrase.new(number_of_words: 3, use_random_org: true)
+        expect(passphrase).to be_using_random_org
+      end
+    end
+
+    context "initialized with default options" do
+      before do
+        @passphrase = Passphrase.new
+        @passphrase.generate
+      end
+
+      it "return a passphrase with the default number of words" do
+        expect(@passphrase.number_of_words).to eq(Default.options[:number_of_words])
+      end
+
+      it "should not be using RANDOM.ORG" do
+        expect(@passphrase).not_to be_using_random_org
+      end
+    end
+  end
+end