passphrase 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 04b13682c8ca0850aec87893eacd4e3ef53bcdd8
-  data.tar.gz: e758d10b4ae02a3b76906512fbd545fd21f461dc
+  metadata.gz: 6f0c06ef87ec317d113d67632f44873e4c0b6c7f
+  data.tar.gz: c144b9ec21879b8717a5c3c3a0f5dc13be273542
 SHA512:
-  metadata.gz: ed1766c82ecf11aab014e0b41fdccb00504f13456671130b5da70f013369d855673a2a4e84548a5c65edda150161b797503e1bcc62e606f99a2d01c29e05e626
-  data.tar.gz: 59d155d31002868739678ddd654ebb2196ebc74e5a852a56afa216f69e18871b8ae311e0194a9de5850fee1dd3329b68b9b1dcc72a2994be83b0442c0cbd8577
+  metadata.gz: f2711c0224023e76b00f2f1fea8358be40ee078edaa1891c3623f9803398cf4d2868261db067e0b9d0e072679cdb385e9b4809934325c06686de5d747c3110f1
+  data.tar.gz: a425a87a7134ffc3efa2262f208f278e0f941a33ea97f1eb35558fa8a68cba03661e139856e5d72a402ff49c6d50cd4ecf9eef950326b54270f8f7383160c07b

checksums.yaml.gz.sig

@@ -1 +1 @@
-|��)�VMg�Ų�<R�)�S�MLy�|�9����
/�����ɟ��.�&:��,����<�Kζ�?��7&�t]f��K1�uN��sc���S��I��x<т�׼iBtGo&J�O���~�[�w��ٕ�O�}�I�ˋ��+�Hg��ŅEG{<��~�R|��5p�.�gMn�,���u��z|(����8;w�.��ౙ���w3`]�/.�u��Ѓ��
_��-�Xa�Ϭ�"�u��j	�[��<N�nC
+�^�殗�I���K�VXV:J��9���l��>�'s�c^(�m����;�*C��A��1�����[r��^	��I������{Tϓ��D�ֹ~R*�tGi�u �^nj���?K1b${p��z�݊1v���ʪeŀ�D�V�c���
>��1L��N�W�C}��:1 ��+)������

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 All notable changes to this project will be documented in this file. This
 project adheres to [Semantic Versioning](http://semver.org/).
 
+## Version 1.1.0 - 2015-04-14
+### Added
+- Added SHA256 checksum calculation to rake_helper.rb.
+- Added `:use_random_org` key to Passphrase#inspect.
+- Added `--passwordize|-p` option to convert a passphrase into a password.
+
+### Changed
+- Made `number_of_words` an attribute of the Passphrase class.
+- Generate a passphrase when a Passphrase object is instantiated.
+- The passphrase attribute is now an instance of PassphraseString which
+  encapsulates the `#to_password` method.
+
 ## Version 1.0.0 - 2015-04-06
 This release is a complete re-write. None of the code from the previous
 release was retained.

data/README.md

@@ -7,12 +7,12 @@ the command-line, run
 
 or programmatically,
 
-    require "passphrase"
-    p = Passphrase::Passphrase.new(number_of_words: 4)
-    p.generate
-    passphrase = p.passphrase
-
-Eliminate the spaces between words to use the result as a potential password.
+```ruby
+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
@@ -41,7 +41,9 @@ this case `sqlite3`, which is not signed, from the verification process.
     Usage: passphrase [options]
         -n, --num-words=NUM           Number of words in passphrase 3..10
                                       (default: 5)
-        -r, --[no-]random-org         Use random.org to generate random numbers
+        -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
@@ -52,30 +54,41 @@ this case `sqlite3`, which is not signed, from the verification process.
     $ passphrase -n 4
     apaisado vermouth seemag ebelik
 
-### Ruby library
-
-    require "passphrase"
-
-    # generate a passphrase with default options
-    p = Passphrase::Passphrase.new
-    p.generate
-    puts "passphrase: #{p}"
-    puts "passphrase internals: #{p.inspect}"
+    $ passphrase -n 3 -p
+    pothvati alewives escatima
+    pothvati_alewiNes_e&cat5ma
 
-    # generate three four-word passphrases using RANDOM.ORG
-    options = { number_of_words: 4, use_random_org: true }
-    p = Passphrase::Passphrase.new(options)
-    passphrase1 = p.generate.passphrase
-    passphrase2 = p.generate.passphrase
-    passphrase3 = p.generate.passphrase
+### Ruby library
 
-    # 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 }
-    end
+```ruby
+require "passphrase"
+
+# generate a passphrase with default options
+p = Passphrase::Passphrase.new
+puts "passphrase: #{p}"
+puts "passphrase internals: #{p.inspect}"
+
+# generate three four-word passphrases using RANDOM.ORG
+options = { number_of_words: 4, use_random_org: true }
+p = Passphrase::Passphrase.new(options)
+passphrase1 = p.generate.passphrase
+passphrase2 = p.generate.passphrase
+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 }
+end
+
+# generate a password
+p = Passphrase::Passphrase.new(number_of_words: 3)
+passphrase = p.passphrase
+password   = passphrase.to_password
+```
 
 ## Background
+### Diceware Method
 Passphrase implements the [Diceware
 Method](http://world.std.com/~reinhold/diceware.html) which constructs a
 passphrase by randomly selecting words from a predefined list of more-or-less
@@ -113,11 +126,11 @@ SQLite 3 database file).
 
 Except in the original Diceware list, all words are lower case, comprised of
 characters from the ascii set `[a-z]`. The original Diceware list includes
-some "words" with numerical and punctuation characters. No word appears more
-than once in this set of wordlists.
+some "words" with numerical and punctuation characters. To the best of my
+knowledge, no word appears more than once in this set of wordlists.
 
 The _dice_ in Diceware refers to the act of rolling a die to achieve
-randomness. A sequence of five consecutive rolls has 7776 (6<sup>5</sup>)
+randomness. A sequence of five consecutive rolls has 7776 (or 6<sup>5</sup>)
 possible outcomes. Each combination maps to one line in a given wordlist, and
 each line, in turn, is composed of between 1 and 15 words (depending on the
 language, the average being 5).
@@ -128,8 +141,8 @@ Therefore, to select a word, Passphrase
 2. randomly selects one of 7776 lines from the corresponding wordlist
 3. randomly selects one word from the corresponding line
 
-This leads to roughly 10<sup>28</sup> possible five-word passphrases, for
-example.
+This leads to roughly 2<sup>66</sup> (or 10<sup>28</sup>) possible five-word
+passphrases, for example.
 
 Passphrase simulates the rolls of a die by using random numbers from one of
 two sources. The default is to use the standard SecureRandom class. You also
@@ -137,8 +150,16 @@ 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.
 
+### Passwords
+A typical passphrase will not satisfy password policies that require the use
+of upper case letters, numbers, and special characters (~, !, and the like).
+Therefore, Passphrase gives you the option to replace three randomly selected
+characters in a generated passphrase with one random upper case letter
+`[A-Z]`, one random integer `[0-9]`, and one random special character. Spaces
+are not usually allowed either, so they are replaced with underscores as part
+of this process.
+
 ## Contributing to Passphrase
-### Getting started
 After forking the [repository on
 GitHub](https://github.com/esumbar/passphrase), go to your local copy of the
 repository  and execute `bundle install` to ensure that all development gems
@@ -154,21 +175,14 @@ 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=>"", :number_of_words=>0, :word_origins=>{}}
-    >> p.generate
-    => {:passphrase=>"bolt flanella ininaen", :number_of_words=>3,...}
+    => {:passphrase=>"jazzy vannier viscount", :number_of_words=>3, ... }
     >> p.passphrase
-    => "bolt flanella ininaen"
+    => "jazzy vannier viscount"
+    >> p.passphrase.to_password
+    => "jazz{_2annier_vBscount"
 
 Run the tests with `rake spec`.
 
-### Future enhancements
-In order to make passphrases more acceptable as passwords, a feature could be
-added to the library to upcase a random letter, replace a random alphabetic
-character with a numeric character (if one does not already exist), and mix in
-a special character, like "`$`" or "`%`" etc. The command-line option could be
-called `--passwordize|-p`.
-
 ## Changelog
 See {file:CHANGELOG.md} for a list of changes.
 

data/lib/passphrase.rb

@@ -1,10 +1,6 @@
 require "passphrase/default"
-require "passphrase/diceware_method"
-require "passphrase/diceware_random"
-require "passphrase/language_query"
 require "passphrase/passphrase"
 require "passphrase/version"
-require "passphrase/word_query"
 
 module Passphrase
   autoload(:CLI, "passphrase/CLI")

data/lib/passphrase/CLI.rb

@@ -14,20 +14,44 @@ module Passphrase
     #   given by ARGV (may be empty)
     # @return [void]
     def self.parse(args)
-      options = Default.options
+      # Gotcha:
+      # The contents of an instance variable can be changed outside the class
+      # through a reader attribute. For example,
+      #   class A
+      #     attr_reader :x
+      #     def initialize
+      #       @x = { a: 1, b: 2 }
+      #     end
+      #   end
+      #   a = A.new
+      #   p a.x        #=> {:a=>1, :b=>2}
+      #   x = a.x
+      #   x[:b] = 99
+      #   p a.x        #=> {:a=>1, :b=>99}
+      # Therefore, need to clone the default hash otherwise parsing could
+      # alter the hash's contents. Although this causes no harm in the
+      # command-line tool, it causes havoc in the test suite.
+      options = Default.options.clone
 
       default_number_of_words = Default.options[:number_of_words]
+      default_passwordize = Default.options[:passwordize] ? "--passwordize" : "--no-passwordize"
       default_random_org = Default.options[:use_random_org] ? "--random-org" : "--no-random-org"
+      default_number_range = Default.number_range
 
       parser = OptionParser.new do |opts|
         opts.banner = "Usage: passphrase [options]"
         opts.on(:REQUIRED, "-n NUM", "--num-words=NUM", Integer,
-          "Number of words in passphrase #{Default.number_range}",
+          "Number of words in passphrase #{default_number_range}",
           "(default: #{default_number_of_words})") do |n|
             options[:number_of_words] = n
           end
+        opts.on(:NONE, "-p", "--[no-]passwordize",
+          "Add one cap, one num, and one special char",
+          "(default: #{default_passwordize})") do |p|
+            options[:passwordize] = p
+        end
         opts.on(:NONE, "-r", "--[no-]random-org",
-          "Use random.org to generate random numbers",
+          "Use RANDOM.ORG to generate random numbers",
           "(default: #{default_random_org})") do |r|
             options[:use_random_org] = r
         end
@@ -44,7 +68,9 @@ module Passphrase
       begin
         parser.parse!(args)
         validate_number_of_words(options)
-        puts Passphrase.new(options).generate
+        passphrase = Passphrase.new(options).passphrase
+        puts passphrase
+        puts passphrase.to_password if options[:passwordize]
       rescue OptionParser::InvalidOption => e
         handle_error(e)
       rescue OptionParser::MissingArgument => e

data/lib/passphrase/default.rb

@@ -9,7 +9,7 @@ module Passphrase
       attr_reader :number_range
     end
 
-    @options = { number_of_words: 5, use_random_org: nil }
+    @options = { number_of_words: 5, passwordize: nil, use_random_org: nil }
     @number_range = (3..10)
   end
 end

data/lib/passphrase/diceware_method.rb

@@ -1,4 +1,7 @@
 require "sqlite3"
+require "passphrase/diceware_random"
+require "passphrase/language_query"
+require "passphrase/word_query"
 
 module Passphrase
   # This class implements the Diceware Method for generating a passphrase. It

data/lib/passphrase/diceware_random.rb

@@ -19,7 +19,7 @@ module Passphrase
 
     # @param use_random_org [Boolean] a flag that triggers the use of
     #   RANDOM.ORG for generating random numbers
-    def initialize(use_random_org=nil)
+    def initialize(use_random_org)
       @random_org_uri = "https://www.random.org"
       use_random_org ? setup_remote_generator : setup_local_generator
     end

data/lib/passphrase/passphrase.rb

@@ -1,3 +1,6 @@
+require "passphrase/diceware_method"
+require "passphrase/passphrase_string"
+
 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
@@ -12,14 +15,15 @@ module Passphrase
     # @return [String] the passphrase string
     attr_reader :passphrase
 
+    # @return [Integer] the number of words in the passphrase
+    attr_reader :number_of_words
+
     # @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 = []
+      @number_of_words = @options[:number_of_words]
+      generate
       yield self if block_given?
     end
 
@@ -27,23 +31,16 @@ module Passphrase
     # 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
+    # @return [self] the Passphrase object
     def generate
       @languages, @die_rolls, @words = DicewareMethod.run(@options)
-      @passphrase = @words.join(" ")
+      @passphrase = PassphraseString.new(@words.join(" "), @options[:use_random_org])
       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
+    # @return [Boolean] returns true if RANDOM.ORG is being used
     def using_random_org?
       @options[:use_random_org]
     end
@@ -51,15 +48,16 @@ module Passphrase
     # String representation of a Passphrase object
     # @return [String] the passphrase string
     def to_s
-      @passphrase
+      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,
+        passphrase: passphrase,
+        number_of_words: number_of_words,
+        use_random_org: using_random_org?,
         word_origins: word_origins
       }
     end

data/lib/passphrase/passphrase_string.rb

@@ -0,0 +1,60 @@
+module Passphrase
+  # This subclass of String implements the {#passwordize} instance method for
+  # substituting a capital letter, number, and special character into a
+  # passphrase.
+  class PassphraseString < String
+    # @param passphrase [String] the passphrase as an ordinary String object
+    # @param use_random_org [Boolean] a flag that triggers the use of
+    #   RANDOM.ORG for generating random numbers
+    def initialize(passphrase, use_random_org)
+      super(passphrase)
+      @use_random_org = use_random_org
+      @random = DicewareRandom.new(use_random_org)
+    end
+    
+    # @return [String] a new String that is the passwordized version of the
+    #   passphrase
+    def to_password
+      @scratch = self.gsub(/\s/, "_")
+      capital_index, number_index, special_index = @random.indices(3, @scratch.length)
+      select_and_substitute_capital_letter(capital_index)
+      select_and_substitute_number(number_index)
+      select_and_substitute_special_character(special_index)
+      String.new(@scratch)
+    end
+
+    private
+
+    def select_and_substitute_capital_letter(random_index)
+      # Just in case the passphrase already includes a capital letter.
+      return if /[A-Z]/ =~ @scratch
+      capital_letter = ("A".."Z").to_a.sample
+      substitute(capital_letter, random_index)
+    end
+
+    def select_and_substitute_number(random_index)
+      # The Diceware wordlist includes "words" that include numbers.
+      return if /[0-9]/ =~ @scratch
+      number = ("0".."9").to_a.sample
+      substitute(number, random_index)
+    end
+
+    def select_and_substitute_special_character(random_index)
+      # The Diceware wordlist includes "words" that include special characters.
+      return if /[~!#\$%\^&\*\(\)\-=\+\[\]\\\{\}:;"'<>\?\/]/ =~ @scratch
+      special_character = %w( ~ ! # $ % ^ & * \( \) - = + [ ] \\ { } : ; " ' < > ? / ).sample
+      substitute(special_character, random_index)
+    end
+
+    def substitute(substitution, random_index)
+      character = @scratch[random_index]
+      @scratch[random_index] = substitution and return if /[a-z]/ =~ character
+      next_index = random_index.succ.modulo(@scratch.length)
+      until next_index == random_index
+        character = @scratch[next_index]
+        @scratch[next_index] = substitution and return if /[a-z]/ =~ character
+        next_index = next_index.succ.modulo(@scratch.length)
+      end
+    end
+  end
+end

data/lib/passphrase/version.rb

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

data/spec/passphrase/cli_spec.rb

@@ -3,6 +3,15 @@ require "optparse"
 
 module Passphrase
   RSpec.describe CLI, "implements the command line interface" do
+    before do
+      @saved_stdout = $stdout
+      $stdout = StringIO.new
+    end
+
+    after(:each) do
+      $stdout = @saved_stdout
+    end
+
     it "responds to class method parse() with one argument" do
       expect(CLI).to respond_to(:parse).with(1).argument
     end
@@ -15,12 +24,35 @@ module Passphrase
       expect(CLI).not_to respond_to(:handle_error)
     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"])
+    end
+
+    it "does not emit an error when option -p is supplied" do
+      expect(CLI).not_to receive(:handle_error)
+      CLI.parse(["-p"])
+    end
+
+    it "does not emit an error when option -r is supplied" do
+      expect(CLI).not_to receive(:handle_error)
+      CLI.parse(["-r"])
+    end
+
+    it "exits when option -h is supplied" do
+      expect { CLI.parse(["-h"]) }.to raise_error(SystemExit)
+    end
+
+    it "exits when option -v is supplied" do
+      expect { CLI.parse(["-v"]) }.to raise_error(SystemExit)
+    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)
+      invalid_option = ["-x"]
+      CLI.parse(invalid_option)
     end
 
     it "emits an error when a mandatory argument is missing" do

data/spec/passphrase/diceware_method_spec.rb

@@ -50,11 +50,19 @@ module Passphrase
           )
         end
 
-        it "each array is of size given by the number of words specified" do
+        it "each array contains :number_of_words elements" do
           @result.each do |result|
             expect(result.size).to eq(@number_of_words)
           end
         end
+
+        it "each array contains String elements" do
+          @result.each do |result|
+            result.each do |element|
+              expect(element).to be_an_instance_of(String)
+            end
+          end
+        end
       end
     end
   end

data/spec/passphrase/diceware_random_spec.rb

@@ -46,6 +46,10 @@ module Passphrase
       it "each one in the range 0...15" do
         expect(@result).to all be_between(0, 14)
       end
+
+      it "produces a different result when called a second time" do
+        expect(@random.indices(4, 15)).not_to eq(@result)
+      end
     end
 
     describe "#die_rolls(6)" do
@@ -82,7 +86,7 @@ module Passphrase
 
     context "initialized by default to use the local Ruby random number generator" do
       before do
-        @random = DicewareRandom.new
+        @random = DicewareRandom.new(false)
       end
       
       include_examples "DicewareRandom object"
@@ -90,11 +94,7 @@ module Passphrase
 
     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)
+        @random = DicewareRandom.new(true)
       end
 
       it "increments the random.org request count on indices()" do

data/spec/passphrase/passphrase_spec.rb

@@ -1,58 +1,91 @@
 require "passphrase"
 
 module Passphrase
+  RSpec.shared_examples "Passphrase object" do
+    it "responds to attribute reader method passphrase()" do
+      expect(@passphrase).to respond_to(:passphrase)
+    end
+
+    it "responds to attribute reader method number_of_words()" do
+      expect(@passphrase).to respond_to(:number_of_words).with(0).arguments
+    end
+
+    it "responds to the generate() method with zero arguments" do
+      expect(@passphrase).to respond_to(:generate).with(0).arguments
+    end
+
+    it "responds to predicate method using_random_org?()" do
+      expect(@passphrase).to respond_to(:using_random_org?)
+    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 "does not respond to the word_origins() method (private)" do
+      expect(@passphrase).not_to respond_to(:word_origins)
+    end
+  end
+
   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)
+      expect { |b| Passphrase.new(&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
+    # Therefore, only need to thoroughly test the case where RANDOM.ORG is not used.
+    context "initialized to use RANDOM.ORG" do
+      it "the predicate method should confirm it is using RANDOM.ORG" do
+        passphrase = Passphrase.new(use_random_org: true)
+        expect(passphrase).to be_using_random_org
       end
+    end
 
-      it "responds to the to_s() method" do
-        expect(@passphrase).to respond_to(:to_s)
+    context "initialized with default options" do
+      before do
+        @passphrase = Passphrase.new
       end
 
-      it "responds to the inspect() method with zero arguments" do
-        expect(@passphrase).to respond_to(:inspect).with(0).arguments
+      it "returns a passphrase of type PassphraseString" do
+        expect(@passphrase.passphrase).to be_an_instance_of(PassphraseString)
       end
-
-      it "responds to attribute reader method passphrase()" do
-        expect(@passphrase).to respond_to(:passphrase)
+      
+      it "returns a passphrase with the default number of words" do
+        number_of_words = @passphrase.passphrase.split.length
+        expect(number_of_words).to eq(Default.options[:number_of_words])
       end
 
-      it "responds to predicate method using_random_org?()" do
-        expect(@passphrase).to respond_to(:using_random_org?)
+      it "should not be using RANDOM.ORG" do
+        expect(@passphrase).not_to be_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
+      include_examples "Passphrase object"
+    end
 
-      it "does not respond to the word_origins() method (private)" do
-        expect(@passphrase).not_to respond_to(:word_origins)
+    context "initialized to generate a passphrase with 1 word" do
+      before do
+        @passphrase = Passphrase.new(number_of_words: 1)
       end
 
-      it "initially contains an empty passphrase string" do
-        expect(@passphrase.passphrase).to be_empty
+      it "returns a passphrase of type PassphraseString" do
+        expect(@passphrase.passphrase).to be_an_instance_of(PassphraseString)
       end
 
-      it "initially contains zero words" do
-        expect(@passphrase.number_of_words).to eq(0)
+      it "returns a passphrase with one word" do
+        number_of_words = @passphrase.passphrase.split.length
+        expect(number_of_words).to eq(1)
       end
 
       it "should not be using RANDOM.ORG" do
         expect(@passphrase).not_to be_using_random_org
       end
 
+      include_examples "Passphrase object"
+
       context "after executing the generate() method" do
         before do
           dwr = [["language"], ["11111"], ["passphrase"]]
@@ -64,12 +97,17 @@ module Passphrase
           expect(@result).to equal(@passphrase)
         end
 
-        it "contains the passphrase string" do
-          expect(@result.passphrase).to eq("passphrase")
+        it "returns a passphrase of type PassphraseString" do
+          expect(@result.passphrase).to be_an_instance_of(PassphraseString)
+        end
+
+        it "contains a passphrase with one word" do
+          number_of_words = @result.passphrase.split.length
+          expect(number_of_words).to eq(1)
         end
 
-        it "contains a number of words equal to one" do
-          expect(@result.number_of_words).to eq(1)
+        it "contains the passphrase string" do
+          expect(@result.passphrase).to eq("passphrase")
         end
 
         it "returns the passphrase when printed" do
@@ -83,6 +121,7 @@ module Passphrase
           expect(@result.inspect).to match(
             passphrase: "passphrase",
             number_of_words: 1,
+            use_random_org: nil,
             word_origins: { "passphrase" => {
               language: "language",
               die_rolls: "11111"
@@ -92,27 +131,5 @@ module Passphrase
         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

data/spec/passphrase/passphrase_string_spec.rb

@@ -0,0 +1,55 @@
+require "passphrase"
+
+module Passphrase
+  RSpec.describe PassphraseString, "subclass of String class" do
+    context "initialized with a sample string" do
+      before do
+        @sample = "a sample passphrase string"
+        @passphrase_string = PassphraseString.new(@sample, false)
+      end
+      
+      it "contains the same string as the sample string" do
+        expect(@passphrase_string).to eq(@sample)
+      end
+
+      it "has the same length as the sample string" do
+        expect(@passphrase_string.length).to eq(26)
+      end
+
+      it "responds to the to_password() method with zero arguments" do
+        expect(@passphrase_string).to respond_to(:to_password).with(0).arguments
+      end
+
+      describe "#to_password" do
+        before do
+          @passwordized_string = @passphrase_string.to_password
+        end
+
+        it "returns an ordinary String" do
+          expect(@passwordized_string).to be_an_instance_of(String)
+        end
+
+        it "returns a String that is not the same object as the PassphraseString" do
+          expect(@passwordized_string).not_to equal(@passphrase_string)
+        end
+
+        it "returns a String that has the same length as the PassphraseString" do
+          expect(@passwordized_string.length).to eq(@passphrase_string.length)
+        end
+
+        it "returns a String that contains at least one captial letter" do
+          expect(@passwordized_string).to match(/[A-Z]/)
+        end
+
+        it "returns a String that contains at least one number" do
+          expect(@passwordized_string).to match(/[0-9]/)
+        end
+
+        it "returns a String that contains at least one special character" do
+          special_character = /[~!#\$%\^&\*\(\)\-=\+\[\]\\\{\}:;"'<>\?\/]/
+          expect(@passwordized_string).to match(special_character)
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: passphrase
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Edmund Sumbar
@@ -30,7 +30,7 @@ cert_chain:
   aoKZhUfRmAZDUgzW4PMtMxO34fQDbDYevBzMcxmkHNDs87ROMOuPLWJGLcKpgGwJ
   TxzUtBfb7E+Qa/wyo0Ws7A==
   -----END CERTIFICATE-----
-date: 2015-04-06 00:00:00.000000000 Z
+date: 2015-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3
@@ -139,6 +139,7 @@ files:
 - 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
@@ -147,6 +148,7 @@ files:
 - 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/spec_helper.rb
 homepage: https://github.com/esumbar/passphrase