spass 0.0.1 → 0.0.2

data/.rspec

@@ -0,0 +1,2 @@
+--format doc
+--color

data/History.md

@@ -0,0 +1,19 @@
+History
+=======
+
+0.0.2
+-----
+
+- Added command-line options
+- Multiple-phrase generation
+- Optional inclusion of digits
+- Restricted word length
+
+
+0.0.1
+-----
+
+- Initial release
+- Single phrase with random lowercase words
+
+

data/README.md

@@ -47,11 +47,10 @@ if you want to use words from a different dictionary, pass a second argument:
 Future plans
 ------------
 
-- Optional inclusion of uppercase, numbers, symbols
+- Optional inclusion of uppercase and symbols
 - Avoid word repetition
 
 
-
 MIT License
 -----------
 

data/bin/spass

@@ -1,13 +1,9 @@
 #!/usr/bin/env ruby
 
-require 'spass' # Is this needed?
+require 'spass'
+require 'optparse'
 
-USAGE = <<EOF
-spass: Generate a passphrase with lowercase words
-
-Usage:
-
-  $ spass <length> [path_to_dict]
+HELP = <<EOF
 
 This script generates a plain-English passphrase of at least the given length
 (in characters), using random words from the given dictionary file
@@ -17,15 +13,12 @@ nonsensical).
 
 Examples:
 
-  $ spass 12
+  $ spass -l 12
   hive frighten
 
-  $ spass 24
+  $ spass -l 24
   moppet castigator harvesters
 
-  $ spass 32
-  munificent icebound raymond clorets
-
 A 32-character passphrase has about 120 bits of entropy, which is overkill for
 most purposes. A 24-character passphrase clocks in at about 90 bits of entropy,
 suitable for most high-security applications like root passwords or financial
@@ -35,18 +28,65 @@ your passphrase after generating one that you like:
   http://rumkin.com/tools/password/passchk.php
 
 Inspired by http://xkcd.com/936/
+
 EOF
 
-if ARGV.count == 0
-  puts USAGE
-else
-  length = ARGV[0].to_i
-  if ARGV[1]
-    sp = SPass.new(ARGV[1])
-  else
-    sp = SPass.new
+options = {
+  :length => 24,
+  :number => 10,
+  :dict => '/usr/share/dict/words',
+  :digits => false,
+  :chars => 10,
+}
+
+optparse = OptionParser.new do |opts|
+  opts.on('-l', '--length [NUM]', Integer,
+          "Ensure passphrases are at least NUM characters.",
+          "Default: #{options[:length]}") do |len|
+    options[:length] = len
+  end
+
+  opts.on('-n', '--number [NUM]', Integer,
+          "Generate NUM passphrases.",
+          "Default: #{options[:number]}") do |num|
+    options[:number] = num
+  end
+
+  opts.on('-f', '--file [FILE]', String,
+          "Read words from a FILE having one word per line.",
+          "Default: #{options[:dict]}") do |dict|
+    options[:dict] = dict
   end
-  puts sp.generate(length)
+
+  opts.on('-d', '--digits',
+          "Include random numbers from 1-99.",
+          "Default: False") do |digits|
+    options[:digits] = digits
+  end
+
+  opts.on('-c', '--chars NUM',
+          "Limit words to NUM characters in length.",
+          "Default: 10") do |chars|
+    options[:chars] = chars
+  end
+
+  opts.on_tail('-h', '--help', 'Display the help page') do
+    puts opts
+    puts HELP
+    exit 0
+  end
+end
+
+begin
+  optparse.parse!
+rescue OptionParser::InvalidOption => e
+  puts optparse
+  puts "*** #{e}"
+  exit 1
 end
 
+sp = Generator.new(options[:dict], options)
+options[:number].times do
+  puts sp.generate(options[:length], :digits=>options[:digits])
+end
 

data/lib/spass.rb

@@ -1,41 +1,47 @@
 
-class SPass
-  attr_reader :dict_path, :dict_lines
-
-  def initialize(dict_path='/usr/share/dict/words')
-    @dict_path = File.expand_path(dict_path)
-    if !File.file?(@dict_path)
-      raise RuntimeError, "Cannot find dict file: #{@dict_path}"
-    end
-    @dict_lines = `wc -l #{@dict_path}`.split.first.to_i
+class Generator
+  # Create a Generator using the given word dictionary, returning
+  # only words that match the given regular expression
+  def initialize(dict_path='/usr/share/dict/words', options={})
+    @dict_path = dict_path
+    @dict = read_dict(dict_path, options)
   end
 
-  # Return a random line number from 1..N where N is the last line
-  # in the dict file
-  def random_line
-    rand(@dict_lines) + 1
+  # Read a word dictionary from the given file, and return an array
+  # of elements that match the allowed regex. Raise an exception if
+  # the given dictionary file cannot be found.
+  def read_dict(path, options={})
+    allowed = options[:allowed] || /^[a-z]+$/
+    chars = (options[:chars] || 10).to_i
+    if !File.file?(path)
+      raise RuntimeError, "Cannot find dict file: #{path}"
+    end
+    dict = []
+    IO.readlines(path).each do |line|
+      line.strip!
+      if line.length <= chars && line =~ allowed
+        dict << line
+      end
+    end
+    return dict
   end
 
-  # Return a random word from the dictionary, lowercased
+  # Return a random word from the dictionary
   def random_word
-    cmd = "sed -n '#{random_line} {p;q;}' '#{@dict_path}'"
-    `#{cmd}`.chomp.downcase
+    @dict[rand(@dict.count)]
   end
 
-  # Return a random word that consists of only lowercase letters
-  def random_ascii_word
-    word = random_word
-    while word =~ /[^a-z]/
-      word = random_word
-    end
-    return word
+  # Return a random number from 1 to 99
+  def random_number
+    1 + rand(99)
   end
 
   # Generate a passphrase of at least the given length in characters
-  def generate(length)
+  def generate(length, options={})
     phrase = ''
     while phrase.length < length + 1 # to account for trailing space
-      phrase += random_ascii_word + ' '
+      phrase += "#{random_word} "
+      phrase += "#{random_number} " if options[:digits]
     end
     return phrase.chomp
   end

data/spass.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "spass"
-  s.version = "0.0.1"
+  s.version = "0.0.2"
   s.summary = "Generate passphrases"
   s.description = <<-EOS
     spass generates passphrases using random words

data/spec/spass_spec.rb

@@ -2,39 +2,33 @@ require 'spass'
 
 TEST_DICT = File.expand_path('../data/ten_words', __FILE__)
 
-describe SPass do
-  before(:each) do
-    @sp = SPass.new(TEST_DICT)
+describe Generator do
+  before(:all) do
+    @sp = Generator.new(TEST_DICT)
   end
 
 
-  describe "#initialize" do
-    it "correctly sets dict_path" do
-      path = TEST_DICT
-      @sp = SPass.new(path)
-      @sp.dict_path.should == path
+  describe "#read_dict" do
+    it "returns an array of lines from the given file" do
+      @sp.read_dict(TEST_DICT).should == [
+        'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']
     end
 
-    it "raises an exception for invalid path" do
-      path = File.expand_path('non/existent/path')
-      lambda do
-        @sp = SPass.new(path)
-      end.should raise_error(RuntimeError, /Cannot find dict file/)
+    it "only returns words matching a regex" do
+      @sp.read_dict(TEST_DICT, :allowed=>/^t/).should == ['two', 'three', 'ten']
+      @sp.read_dict(TEST_DICT, :allowed=>/^f/).should == ['four', 'five']
+      @sp.read_dict(TEST_DICT, :allowed=>/e$/).should == ['one', 'three', 'five', 'nine']
     end
-  end
-
 
-  describe "#random_line" do
-    it "is >= 1" do
-      100.times do
-        @sp.random_line.should be >= 1
-      end
+    it "only returns words with N chars or fewer" do
+      @sp.read_dict(TEST_DICT, :chars=>3).should == ['one', 'two', 'six', 'ten']
     end
 
-    it "is <= number of lines" do
-      100.times do
-        @sp.random_line.should be <= @sp.dict_lines
-      end
+    it "raises an exception when the file does not exist" do
+      path = File.expand_path('non/existent/path')
+      lambda do
+        @sp.read_dict(path)
+      end.should raise_error(RuntimeError, /Cannot find dict file/)
     end
   end
 
@@ -48,14 +42,17 @@ describe SPass do
   end
 
 
-  describe "#random_ascii_word" do
-    it "only includes lowercase letters" do
-      10.times do
-        @sp.random_ascii_word.should =~ /^[a-z]+$/
+  describe "#random_number" do
+    it "returns a number between 1 and 999" do
+      1000.times do
+        num = @sp.random_number
+        num.should be >= 1
+        num.should be <= 99
       end
     end
   end
 
+
   describe "#generate" do
     it "is at least the given length" do
       [10, 15, 20, 25, 30, 35, 40].each do |len|
@@ -64,6 +61,12 @@ describe SPass do
         end
       end
     end
+
+    it "includes digits when :digits is true" do
+      10.times do
+        @sp.generate(24, :digits=>true).should =~ /^([a-z]+ [0-9]+ ?)+$/
+      end
+    end
   end
 end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: spass
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Eric Pierce
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-30 00:00:00 -06:00
+date: 2011-11-01 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -58,8 +58,10 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
+- .rspec
 - Gemfile
 - Gemfile.lock
+- History.md
 - README.md
 - bin/spass
 - lib/spass.rb