keybox 1.1.0 → 1.1.1

data/spec/storage_record_spec.rb

@@ -1,63 +1,63 @@
 require 'keybox/storage'
 
-context 'a storage record entry' do
-    setup do
+describe 'a storage record entry' do
+    before(:each) do
         @data_fields = %w(title username password url additional_data)
     end
-    specify 'has a creation date set on instantiation' do
+    it 'has a creation date set on instantiation' do
         e = Keybox::Storage::Record.new
-        e.creation_time.should_be_instance_of(Time)
+        e.creation_time.should be_instance_of(Time)
     end
 
-    specify "assigning to a non-existant field creates the appropriate member " do
+    it "assigning to a non-existant field creates the appropriate member " do
         e = Keybox::Storage::Record.new
         e.junk = "junk"
         e.junk.should == "junk"
     end
 
-    specify 'default values for non-existant fields is nil' do 
+    it 'default values for non-existant fields is nil' do 
         e = Keybox::Storage::Record.new
         @data_fields.each do |f|
-            e.send(f).should_be  nil
+            e.send(f).should == nil
         end
     end
 
-    specify "assigning to a field makes the modification time > creation time" do
+    it "assigning to a field makes the modification time > creation time" do
         e = Keybox::Storage::Record.new
         sleep 1
         e.testing = "testing"
-        e.modification_time.should_satisfy { |m| m > e.creation_time }
+        e.modification_time.should > e.creation_time 
         e.last_access_time.should == e.modification_time
     end
 
-    specify "reading a field after assignment the access time > modification time " do
+    it "reading a field after assignment the access time > modification time " do
         e = Keybox::Storage::Record.new
         e.testing = "testing"
         sleep 1
         e.testing
-        e.last_access_time.should_satisfy { |la| la > e.creation_time }
-        e.last_access_time.should_satisfy { |la| la > e.modification_time }
+        e.last_access_time.should > e.creation_time 
+        e.last_access_time.should > e.modification_time
     end
 
-    specify "assigning to a modification, creation or acces_time should raise and exception " do
+    it "assigning to a modification, creation or acces_time should raise and exception " do
         e = Keybox::Storage::Record.new
-        lambda {e.modification_time = Time.now}.should_raise NoMethodError
+        lambda {e.modification_time = Time.now}.should raise_error(NoMethodError)
     end
 
-    specify "assiging multiple items should raise an argument exception" do
+    it "assiging multiple items should raise an argument exception" do
         e = Keybox::Storage::Record.new
-        lambda {e.send(:stuff=,1,2)}.should_raise ArgumentError
+        lambda {e.send(:stuff=,1,2)}.should raise_error(ArgumentError)
     end
 
-    specify "calling a method with arguments should raise exception" do
+    it "calling a method with arguments should raise exception" do
         e = Keybox::Storage::Record.new
-        lambda {e.stuff(1,2)}.should_raise NoMethodError
+        lambda {e.stuff(1,2)}.should raise_error(NoMethodError)
     end
 
-    specify "comparison between records is valid" do
+    it "comparison between records is valid" do
         e = Keybox::Storage::Record.new
         f = e.dup
-        e.should_eql e.uuid
-        e.should_eql f
+        e.should == e.uuid
+        e.should == f
     end
 end

data/spec/string_generator_spec.rb

@@ -1,114 +1,112 @@
 require 'keybox'
-context "string generator" do
-    setup do
+describe Keybox::StringGenerator  do
+    before(:each) do
         @generator = Keybox::StringGenerator.new
     end
 
-    specify "should not be used alone" do
-        lambda { @generator.generate }.should_raise Keybox::KeyboxError
+    it "should not be used alone" do
+        lambda { @generator.generate }.should raise_error(Keybox::KeyboxError)
     end
 
-    specify "cannot have a min length greater than a max length" do
+    it "cannot have a min length greater than a max length" do
         @generator.min_length = 90
-        lambda { @generator.generate }.should_raise Keybox::ValidationError
-        @generator.min_length = 8
+        lambda { @generator.generate }.should raise_error(Keybox::ValidationError)
     end
     
-    specify "cannot have a max length less than a min length" do
+    it "cannot have a max length less than a min length" do
         @generator.max_length = 2
-        lambda { @generator.generate }.should_raise Keybox::ValidationError
-        @generator.max_length = 10
+        lambda { @generator.generate }.should raise_error(Keybox::ValidationError)
     end
 
-    specify "initially there are no chunks" do
-        @generator.chunks.should_have(0).entries
+    it "initially there are no chunks" do
+        @generator.chunks.should have(0).entries
     end
 end
 
-context "chargram generator" do
-    setup do 
+describe "chargram generator" do
+    before(:each) do 
         @generator = Keybox::CharGramGenerator.new
     end
 
-    specify "should have a positive size" do
-        @generator.size.should_be > 26
+    it "should have a positive size" do
+        @generator.size.should > 26
     end
 
-    specify "should emit a string with length > 0" do
-        @generator.generate_chunk.size.should_be > 0
+    it "should emit a string with length > 0" do
+        @generator.generate_chunk.size.should > 0
     end
 
-    specify "should emit an array " do
-        @generator.generate_chunk.should_be_instance_of String
+    it "should emit an array " do
+        @generator.generate_chunk.should be_instance_of(String)
     end
 
-    specify "2 succesive emits should have a common first and last character" do
+    it "2 succesive emits should have a common first and last character" do
         one = @generator.generate_chunk
         two = @generator.generate_chunk
         one[-1].should == two[0]
     end
 
-    specify "2 calls to generate_chunk should have a string that is 1 less than the 2 chunks" do
+    it "2 calls to generate_chunk should have a string that is 1 less than the 2 chunks" do
         one = @generator.generate_chunk
         two = @generator.generate_chunk
         @generator.to_s.length.should == (one.length + two.length - 1)
     end
 end
 
-context "SymbolSetGenerator" do
-    setup do 
+describe "SymbolSetGenerator" do
+    before(:each) do 
         @generator = Keybox::SymbolSetGenerator.new
     end
 
-    specify "symbol sets have the right number or characters" do
+    it "symbol sets have the right number or characters" do
         Keybox::SymbolSetGenerator::ALL.size.should == 92
     end
 
-    specify "generating chunks should produce an array" do
+    it "generating chunks should produce an array" do
         12.times do 
             @generator.generate_chunk
         end
-        @generator.chunks.should_have(12).entries
+        @generator.chunks.should have(12).entries
     end
 
-    specify "generate should produce a string" do
-        @generator.generate.should_be_instance_of(String)
-        @generator.to_s.size.should_be > 0
+    it "generate should produce a string" do
+        @generator.generate.should be_instance_of(String)
+        @generator.to_s.size.should > 0
     end
 
-    specify "generating chunks can be cleared" do
+    it "generating chunks can be cleared" do
         @generator.generate
         @generator.clear
-        @generator.chunks.should_have(0).entries
+        @generator.chunks.should have(0).entries
     end
 
-    specify "min and max lengths are respected" do
+    it "min and max lengths are respected" do
         @generator.max_length = 25
         @generator.min_length = 25
-        @generator.generate.size.should_be == 25
+        @generator.generate.size.should == 25
     end
 
-    specify "required sets are utilized" do
+    it "required sets are utilized" do
         gen = Keybox::SymbolSetGenerator.new([Keybox::SymbolSet::NUMERAL_ASCII, Keybox::SymbolSet::LOWER_ASCII])
         gen.required_sets << Keybox::SymbolSet::UPPER_ASCII
         p = gen.generate
-        gen.required_sets.flatten.uniq.should_include(p[0].chr)
+        gen.required_sets.flatten.uniq.should be_include(p[0].chr)
     end
-    specify "required sets are merged with symbol sets" do
+    it "required sets are merged with symbol sets" do
         gen = Keybox::SymbolSetGenerator.new([Keybox::SymbolSet::NUMERAL_ASCII, Keybox::SymbolSet::LOWER_ASCII])
         gen.required_sets << Keybox::SymbolSet::UPPER_ASCII
         gen.required_sets.flatten.uniq.each do |c|
-            gen.symbols.should_include(c)
+            gen.symbols.should be_include(c)
         end
     end
 
-    specify "generated passwords autoclear" do
+    it "generated passwords autoclear" do
         @generator.generate.should_not == @generator.generate
     end
 
-    specify "setting min and max should not affect " do
+    it "setting min and max should not affect " do
         g = Keybox::SymbolSetGenerator.new(Keybox::SymbolSet::ALL)
-        g.generate.should_be_instance_of(String)
+        g.generate.should be_instance_of(String)
     end
 
 end

data/spec/uuid_spec.rb

@@ -1,29 +1,30 @@
 require 'keybox/uuid'
-context "UUID class" do
-    specify "should have 16 bytes" do
+describe "UUID class" do
+    it "should have 16 bytes" do
         uuid = Keybox::UUID.new
         uuid.bytes.size.should == 16 
     end
 
-    specify "as an array should have 16 members" do
+    it "as an array should have 16 members" do
         uuid = Keybox::UUID.new
         uuid.to_a.size.should == 16
     end
 
-    specify "array elements should have values between 0 and 256 " do
+    it "array elements should have values between 0 and 256 " do
         uuid = Keybox::UUID.new
         uuid.to_a.each do |b|
-            b.should_satisfy { |s| s.between?(0,256) }
+            b.should >= 0
+            b.should <= 256
         end
     end
 
-    specify "as a string should match regex" do
+    it "as a string should match regex" do
         regex = Keybox::UUID::REGEX
         uuid  = Keybox::UUID.new
-        uuid.to_s.should_match(regex)
+        uuid.to_s.should =~ regex
     end
 
-    specify "initialized with a string should give a valid uuid" do
+    it "initialized with a string should give a valid uuid" do
         s      = "0123456789abcdef"
         s_a    = s.unpack("C*")
         s_uuid = sprintf(Keybox::UUID::FORMAT,*s_a)
@@ -31,44 +32,44 @@ context "UUID class" do
         uuid.to_s.should == s_uuid
     end
 
-    specify "initialized with a string in the format of a uuid is valid " do
+    it "initialized with a string in the format of a uuid is valid " do
         s = "c8b5a23a-2507-4834-ab19-60f2cb2a5271"
         uuid = Keybox::UUID.new(s)
         uuid.to_s.should == s
     end
     
-    specify "not enough bytes should throw an expeption" do
+    it "not enough bytes should throw an expeption" do
         s = "0123456789"
-        lambda { Keybox::UUID.new(s) }.should_raise ArgumentError
+        lambda { Keybox::UUID.new(s) }.should raise_error(ArgumentError)
     end
 
-    specify "invalid uuid string should throw an exception" do
+    it "invalid uuid string should throw an exception" do
         s = "z8b5a23a-2507-4834-ab19-60f2cb2a5271"
-        lambda { Keybox::UUID.new(s) }.should_raise ArgumentError
+        lambda { Keybox::UUID.new(s) }.should raise_error(ArgumentError)
     end
 
-    specify "initialing with a non-string raises an exception" do
-        lambda { Keybox::UUID.new(42) }.should_raise ArgumentError
+    it "initialing with a non-string raises an exception" do
+        lambda { Keybox::UUID.new(42) }.should raise_error(ArgumentError)
     end
 
-    specify "should equal another keybox created with same data" do
+    it "should equal another keybox created with same data" do
         s = "c8b5a23a-2507-4834-ab19-60f2cb2a5271"
         one = Keybox::UUID.new(s)
         two = Keybox::UUID.new(s)
         one.should == two
     end
 
-    specify "should equal a string that is the same uuid" do
+    it "should equal a string that is the same uuid" do
         s = "c8b5a23a-2507-4834-ab19-60f2cb2a5271"
         one = Keybox::UUID.new(s)
         one.should == s
     end
 
-    specify "should not equal some other uuid or random string" do
+    it "should not equal some other uuid or random string" do
         s = "c8b5a23a-2507-4834-ab19-60f2cb2a5271"
         one = Keybox::UUID.new(s)
-        one.should_not_eql Keybox::UUID.new
-        one.should_not_eql "i love ruby"
-        one.should_not_eql 4
+        one.should_not == Keybox::UUID.new
+        one.should_not == "i love ruby"
+        one.should_not == 4
     end
 end

data/vendor/highline/highline.rb

@@ -29,7 +29,7 @@ require "abbrev"
 #
 class HighLine
   # The version of the installed library.
-  VERSION = "1.2.6".freeze
+  VERSION = "1.2.9".freeze
   
   # An internal HighLine error.  User code does not need to trap this.
   class QuestionError < StandardError
@@ -48,6 +48,19 @@ class HighLine
   def self.use_color?
     @@use_color
   end
+  
+  # The setting used to disable EOF tracking.
+  @@track_eof = true
+  
+  # Pass +false+ to _setting_ to turn off HighLine's EOF tracking.
+  def self.track_eof=( setting )
+    @@track_eof = setting
+  end
+  
+  # Returns true if HighLine is currently tracking EOF for input.
+  def self.track_eof?
+    @@track_eof
+  end
 
   # The setting used to control color schemes.
   @@color_scheme = nil
@@ -75,7 +88,9 @@ class HighLine
   # An alias for CLEAR.
   RESET      = CLEAR
   # Erase the current line of terminal output.
-  ERASE_LINE = "\e[K" 
+  ERASE_LINE = "\e[K"
+  # Erase the character under the cursor.
+  ERASE_CHAR = "\e[P"
   # The start of an ANSI bold sequence.
   BOLD       = "\e[1m"
   # The start of an ANSI dark sequence.  (Terminal support uncommon.)
@@ -189,9 +204,11 @@ class HighLine
     @question ||= Question.new(question, answer_type, &details)
     
     return gather if @question.gather
-    
-    # readline() needs to handle it's own output
-    say(@question) unless @question.readline
+  
+    # readline() needs to handle it's own output, but readline only supports 
+    # full line reading.  Therefore if @question.echo is anything but true, 
+    # the prompt will not be issued. And we have to account for that now.
+    say(@question) unless (@question.readline and @question.echo == true)
     begin
       @answer = @question.answer_or_default(get_response)
       unless @question.valid_answer?(@answer)
@@ -573,7 +590,8 @@ class HighLine
 
       answer
     else
-      raise EOFError, "The input stream is exhausted." if @input.eof?
+      raise EOFError, "The input stream is exhausted." if @@track_eof and
+                                                          @input.eof?
 
       @question.change_case(@question.remove_whitespace(@input.gets))
     end
@@ -598,24 +616,46 @@ class HighLine
         raw_no_echo_mode if stty = CHARACTER_MODE == "stty"
         
         line = ""
+        backspace_limit = 0
         begin
+
           while character = (stty ? @input.getc : get_character(@input))
-            line << character.chr
+            # honor backspace and delete
+            if character == 127 or character == 8
+              line.slice!(-1, 1)
+              backspace_limit -= 1
+            else
+              line << character.chr
+              backspace_limit = line.size
+            end
             # looking for carriage return (decimal 13) or
             # newline (decimal 10) in raw input
             break if character == 13 or character == 10 or
                      (@question.limit and line.size == @question.limit)
-            @output.print(@question.echo) if @question.echo != false
-          end
-          if @question.overwrite
-            @output.print("\r#{ERASE_LINE}")
-            @output.flush
-          else
-            say("\n")
+            if @question.echo != false
+              if character == 127 or character == 8 
+                  # only backspace if we have characters on the line to
+                  # eliminate, otherwise we'll tromp over the prompt
+                  if backspace_limit >= 0 then
+                    @output.print("\b#{ERASE_CHAR}")
+                  else 
+                      # do nothing
+                  end
+              else
+                @output.print(@question.echo)
+              end
+              @output.flush
+            end
           end
         ensure
           restore_mode if stty
         end
+        if @question.overwrite
+          @output.print("\r#{ERASE_LINE}")
+          @output.flush
+        else
+          say("\n")
+        end
         
         @question.change_case(@question.remove_whitespace(line))
       end