rassphrase 0.0.1 → 0.1

data/Changelog

@@ -0,0 +1,7 @@
+0.1 (October 31, 2011)
+  Defaults :capitalize to true
+  Add option hash argument to Rassphrase#generate
+  Add boolean argument to Rassphrase#passphrase, that indicates capitalization
+  Rename Rassphrase#generate_code to Rassphrase#random_code
+  Add class method Rassphrase::generate
+  Overwrote Rassphrase#to_s

data/README.md

@@ -3,3 +3,76 @@ rassphrase
 
 rassphrase is an implementation of the Diceware passphrase method for Ruby. 
 It's used to generate secure passphrase used for passwords.
+
+What is Diceware?
+=================
+
+Diceware™ is a method for picking passphrases that uses dice to select words at 
+random from a special list called the Diceware Word List. Each word in the list 
+is preceded by a five digit number. All the digits are between one and six, 
+allowing you to use the outcomes of five dice rolls to select one unique word from the list.
+
+More information about the Diceware method @ [http://diceware.com](http://diceware.com "Diceware Homepage")
+
+
+Install
+-------
+
+### Gems
+
+To install the latest "stable" version:
+
+    $ gem install rassphrase
+
+To install the development version:
+
+    $ git clone git://github.com/guzart/rassphrase.git
+    $ cd rassphrase
+    $ git pull origin develop
+    $ git branch develop
+    $ rake install
+
+### Bundler (inside your Gemfile)
+
+To install the latest "stable" version:
+
+    gem 'rassphrase'
+
+To install the development version:
+
+    gem 'rassphrase', :git => "git://github.com/guzart/rassphrase.git", :branch => "develop"
+
+Usage
+-----
+
+### Ruby
+
+Using an instance
+
+    require 'rassphrase'
+    rassphrase = Rassphrase::Rassphrase.new(:capitalize => true)
+    password = rassphrase.generate(10)
+
+Using the class method
+
+    # Generates an array of 10 passphrases
+    require 'rassphrase'
+    passphrases = Rassphrase::Rassphrase.generate({:count => 10})
+
+#### Options
+
++ **size** => Integer - The number of words that make a passphrase.
++ **capitalize** => Boolean - Indicates if the words in the passphrase should be capitalized.
++ **use_beale** => Boolean - Indicate if it should use the beale wordlist.
++ **wordlist_path** => String - A path to a wordlist to use
+
+### Binary
+
+rassphrase comes with a binary called....(drum roll) rassphrase.
+
+    rassphrase [options]
+      -h          Shows the command options
+      -s SIZE     The number of words in the passphrase
+      -c          Capitalizes the words
+      -b          Uses the Beale wordlist. More info @ diceware.com
+      -n NUMBER   The number of different passphrase to generate, one per line

data/bin/rassphrase

@@ -18,8 +18,8 @@ optparse = OptionParser.new do |opts|
     @options[:size] = s
   end
 
-  opts.on("-c", "Capitalizes the words in the passphrase") do
-    @options[:capitalize] = true
+  opts.on("-c", "--[no-]capitalize", "Capitalizes the words in the passphrase") do |c|
+    @options[:capitalize] = c
   end
 
   opts.on("-b", "Uses the Beale wordlist dictionary.") do |w|

data/features/step_definitions/diceware_steps.rb

@@ -10,7 +10,7 @@ end
 
 When /^I ask for a diceware code$/ do
   @dice_rolls_before_code = @dice.roll_count
-  @code = @rassphrase.generate_code
+  @code = @rassphrase.random_code
 end
 
 Then /^the dice should roll (\d+) times$/ do |times|

data/features/step_definitions/generate_passphrase_steps.rb

@@ -7,7 +7,7 @@ When /^I generate a passphrase with (\d+) words$/ do |word_count|
 end
 
 Then /^I get a passphrase with concatenated words$/ do
-  @passphrase.should == @rassphrase.words.join
+  @passphrase.downcase.should == @rassphrase.words.join.downcase
 end
 
 Then /^all the words are different$/ do

data/lib/rassphrase/dice.rb

@@ -1,15 +1,21 @@
 module Rassphrase
+  # Simulates a dice
   class Dice
+    # Creates a new instance of a dice
     def initialize
       @random = Random.new
       @roll_count = 0
     end
 
+    # Returns a random number between 1 and the
+    # number of sides in the dice.
     def roll
       @roll_count += 1
       @random.rand(1..6)
     end
 
+    # Indicates the number of times the dice
+    # has been rolled.
     def roll_count
       @roll_count
     end

data/lib/rassphrase/rassphrase.rb

@@ -1,64 +1,107 @@
 module Rassphrase
   class Rassphrase
+
+    def self.generate(options = {})
+      r = self.new(options)
+      count = options[:count] || 1
+      passphrases = []
+      count.times do 
+        passphrases << r.generate
+      end
+      return passphrases.first if count == 1
+      passphrases
+    end
+
     
+    # Initializes an instance of Rassphrase with the specified options
+    # 
+    # The rassphrase options are:
+    # * :dice => An instance of a class with a method roll, that returns a random number.
+    # * :size => The default number of words in a passphrase
+    # * :capitalize => Indicates if the words should be capitalize in the passphrase [defaults to true]
+    # * :wordlist_path => A path to a file containing a wordlist
+    # * :wordlist => The hash to use as a wordlist
     def initialize(options = {})
       @wordlist = []
       @dice = options[:dice] || Dice.new
       @size = options[:size] || 5
-      @capitalize = options[:capitalize] || false
+      @capitalize = options[:capitalize] || true
       wordlist_path = options[:wordlist_path] || File.expand_path('../../diceware.wordlist', __FILE__)
       self.wordlist = options[:wordlist] || WordlistParser::parse(wordlist_path)
       self.generate
     end
 
+    # The codes for the words used in the current passphrase.
     def codes
       @codes ||= []
     end
 
-    def generate(size = nil)
-      size ||= @size
+    # Generates a new passphrase.
+    # If a size is specified then it generates a passphrase with the given size.
+    def generate(options = nil)
+      capitalize = @capitalize
+      if options.kind_of?(Hash)
+        size = options[:size] || @size
+        capitalize = options[:capitalize] if options.has_key?(:capitalize)
+      else
+        size = options || @size
+      end
       @words, @codes = [], []
       size.times do
         item = random_item
         @codes << item[:code]
         @words << item[:word]
       end
-      self.passphrase
+      self.passphrase(capitalize)
     end
 
-    def generate_code
+    # Generates random code
+    def random_code
       code = ''
       5.times { code << @dice.roll.to_s }
       return code
     end
 
+    # Returns the size of the passphrase
     def length
       self.words.length
     end
 
-    def passphrase
-      return self.words.join unless @capitalize
+    alias :size :length
+
+    # Returns the generated passphrase
+    def passphrase(capitalize = nil)
+      capitalize = @capitalize if capitalize == nil
+      return self.words.join unless capitalize
       self.words.map { |w| w.capitalize }.join
     end
 
+    # Returns a random item from the wordlist
     def random_item
       word = nil
       until word do
-        code = self.generate_code
+        code = self.random_code
         word = self.word(code)
       end
       {:code => code, :word => word}
     end
 
+    def to_s
+      self.passphrase
+    end
+
+    # Returns the word for the specified code searching the wordlist.
     def word(code)
       @wordlist[code.to_s]
     end
 
+    # Assigns a new wordlist
     def wordlist=(wordlist)
       wordlist = WordlistParser::parse(wordlist) if wordlist.is_a?(String) && File.file?(wordlist)
       @wordlist = wordlist.inject({}){ |wl, (k,v)| wl[k.to_s] = v; wl}
     end
 
+    # Returns the words used in the passphrase
     def words
       @words ||= []
     end

data/lib/rassphrase/version.rb

@@ -1,3 +1,3 @@
 module Rassphrase
-  VERSION = "0.0.1"
+  VERSION = "0.1"
 end

data/lib/rassphrase/wordlist_parser.rb

@@ -1,16 +1,28 @@
 module Rassphrase
+  # Parses a file into a Hash, where the key is the 
+  # code, and the value is the word.
+  # The file should have an item per line, where the code and the word
+  # are separated by a space.
+  # Example:
+  # 12345 hello
+  # 12346 world
+  # 12351 foo
   class WordlistParser
+
+    # Parses a line into a hash with :code, and :word.
     def self.parse_line(line)
       items = line.split(' ')
       {:code => items[0], :word => items[1]}
     end
 
+    # Parses a file with wordlist items.
+    # A path to the file must be given as the first argument.
     def self.parse(file_path)
       wordlist = {}
       File.open(file_path, 'r') do |file|
         while line = file.gets
           parts = self.parse_line(line)
-          wordlist[parts[:code]] = parts[:word]
+          wordlist[parts[:code].to_s] = parts[:word]
         end
       end
       return wordlist

data/rassphrase.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |s|
   s.authors     = ["Arturo Guzman"]
   s.email       = ["arturo@agrdt.com"]
   s.homepage    = "https://github.com/guzart/rassphrase"
-  s.summary     = "A Ruby implementation of Diceware passphrase"
-  s.description = "Uses the Diceware passphrase dictionary and method to generate secure passphrases."
+  s.summary     = "A Ruby implementation of Diceware passphrase."
+  s.description = "Uses the Diceware method and method to generate secure passphrases."
 
   s.rubyforge_project = "rassphrase"
 

data/spec/rassphrase/rassphrase_spec.rb

@@ -6,6 +6,34 @@ module Rassphrase
     let(:rassphrase) { Rassphrase.new }
     let(:beale_path) { File.expand_path("../../../lib/beale.wordlist", __FILE__) }
 
+    describe "::generate" do
+      it "defaults to 5 words" do
+        pending 'not sure how to do this test'
+      end
+
+      it "defaults to generate 1 passphrase" do
+        Rassphrase.generate.should be_an_instance_of(String)
+      end
+
+      it "defaults to capitalize words" do 
+        pending 'not sure how to do this test'
+      end
+
+      context "accepts a hash argument that" do
+        it "uses :size to specify the size of the passphrase" do
+          pending 'same as defaults to 5 words'
+        end
+
+        it "uses :capitalize to return passphrase with capitalize words" do
+          pending 'same as defuaults to capitalize'
+        end
+
+        it "uses :count to indicate how many passphrases should be generated" do
+          Rassphrase.generate(:count => 5).should have(5).passphrases
+        end
+      end
+    end
+
     describe "#initialize" do
       it "deaults to use the diceware wordlist" do
         rassphrase.word("12345").should == "apathy"
@@ -15,14 +43,18 @@ module Rassphrase
         rassphrase.should have(5).words
       end
 
-      it "generates a passphrase" do
-        rassphrase.passphrase.should have_at_least(4).characters
+      it "capitalizes words by default" do
+        rassphrase.passphrase.should == rassphrase.words.map{|w| w.capitalize}.join
       end
 
-      context "accepts a hash argument with the option" do
+      it "generates an initial passphrase" do
+        rassphrase.words.should_not be_empty
+      end
+
+      context "accepts a hash argument with" do
         it ":dice to specify the dice" do
           dice = Dice.new
-          Rassphrase.new(:dice => dice).generate_code
+          Rassphrase.new(:dice => dice).random_code
           dice.roll_count.should > 0
         end
 
@@ -70,19 +102,46 @@ module Rassphrase
         rassphrase.generate(8)
         rassphrase.should have(8).words
       end
+
+      context "accepts a hash argument with" do
+        it ":size to specify the size of the passphrase" do
+          rassphrase.generate(:size => 10)
+          rassphrase.should have(10).words
+        end
+
+        it ":capitalize to specify if words should be capitalized" do
+          passphrase = rassphrase.generate(:capitalize => false)
+          passphrase.should == rassphrase.words.join
+        end
+      end
     end
 
-    describe "#generate_code" do
+    describe "#length" do
+      it "returns the number of words in the passphrase" do
+        rassphrase.should have(5).words
+        rassphrase.generate(9)
+        rassphrase.should have(9).words
+      end
+    end
+
+    describe "#passphrase" do
+      it "returns the generated passphrase" do
+        passphrase = rassphrase.generate
+        rassphrase.passphrase.should == passphrase
+      end
+    end
+
+    describe "#random_code" do
       it "returns five characters" do
-        rassphrase.generate_code.size.should be 5
+        rassphrase.random_code.size.should be 5
       end
 
       it "returns only numeric characters" do
-        rassphrase.generate_code.should match /\d{5}/
+        rassphrase.random_code.should match /\d{5}/
       end
 
       it "returns numeric characters between 1 and 6" do
-        code = rassphrase.generate_code.split('')
+        code = rassphrase.random_code.split('')
         code.each do |c|
           c.to_i.should be <= 6
           c.to_i.should be >= 1
@@ -90,14 +149,6 @@ module Rassphrase
       end
     end
 
-    describe "#length" do
-      it "returns the number of words in the passphrase" do
-        rassphrase.should have(5).words
-        rassphrase.generate(9)
-        rassphrase.should have(9).words
-      end
-    end
-
     describe "#random_item" do
       it "returns a random code and word pair from the word list" do
         item = rassphrase.random_item
@@ -109,6 +160,12 @@ module Rassphrase
       end
     end
 
+    describe "#to_s" do
+      it "returns the passphrase" do
+        rassphrase.to_s.should == rassphrase.passphrase
+      end
+    end
+
     describe "#word" do
       before(:each) { rassphrase.wordlist = wordlist }
       
@@ -127,7 +184,7 @@ module Rassphrase
 
     describe "#words" do
       it "returns the words used in the passphrase" do
-        rassphrase.passphrase.should == rassphrase.words.join
+        rassphrase.passphrase.downcase.should == rassphrase.words.join.downcase
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rassphrase
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: '0.1'
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-31 00:00:00.000000000Z
+date: 2011-11-01 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2153182440 !ruby/object:Gem::Requirement
+  requirement: &2155894420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153182440
+  version_requirements: *2155894420
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &2153182020 !ruby/object:Gem::Requirement
+  requirement: &2155893400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,9 +32,8 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153182020
-description: Uses the Diceware passphrase dictionary and method to generate secure
-  passphrases.
+  version_requirements: *2155893400
+description: Uses the Diceware method and method to generate secure passphrases.
 email:
 - arturo@agrdt.com
 executables:
@@ -43,6 +42,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- Changelog
 - Gemfile
 - README.md
 - Rakefile
@@ -89,7 +89,7 @@ rubyforge_project: rassphrase
 rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: A Ruby implementation of Diceware passphrase
+summary: A Ruby implementation of Diceware passphrase.
 test_files:
 - features/diceware.feature
 - features/generate_passphrase.feature