secure_string 1.2.1 → 1.3.0

data/README.rdoc

@@ -83,10 +83,10 @@ Additionally, you can get at the byte data in various ways:
 
 One can initialize a SecureString from any of these types like so:
 
-  ss1 = SecureString.new(:data, "Hello World!")
-  ss2 = SecureString.new(:hex, "48656c6c6f20576f726c6421")
-  ss3 = SecureString.new(:int, 22405534230753928650781647905)
-  ss4 = SecureString.new(:base64, "SGVsbG8gV29ybGQh")
+  ss1 = SecureString.new("Hello World!", :type => :data)
+  ss2 = SecureString.new("48656c6c6f20576f726c6421", :type => :hex)
+  ss3 = SecureString.new(22405534230753928650781647905, :type => :int)
+  ss4 = SecureString.new("SGVsbG8gV29ybGQh", :type => :base64)
   
   ss1 == ss --> true
   ss2 == ss --> true
@@ -104,9 +104,9 @@ The SecureString::Base64Methods module adds +to_base64+, which we've seen:
 It also adds +from_base64+, which can decode a Base64 encoded string.  The
 following example shows the various ways of decoding Bas64 data:
 
-  SecureString.new(:base64, "SGVsbG8gV29ybGQh") == "Hello World!"    --> true
-  SecureString.new("SGVsbG8gV29ybGQh") == "Hello World!"             --> false
-  SecureString.new("SGVsbG8gV29ybGQh").from_base64 == "Hello World!" --> true
+  SecureString.new("SGVsbG8gV29ybGQh", :type => :base64) == "Hello World!"    --> true
+  SecureString.new("SGVsbG8gV29ybGQh") == "Hello World!"                      --> false
+  SecureString.new("SGVsbG8gV29ybGQh").from_base64 == "Hello World!"          --> true
 
 == Digest Methods Overview
 
@@ -234,6 +234,11 @@ or directly via e-mail at:
 mailto:jeff@paploo.net
 
 = Version History
+[1.3.0 - 2011-Jun-15] Ruby 1.8 compatibility.
+                      * (FEATURE) Emulation urlsafe base64 encodings in ruby 1.8.
+                      * (CHANGE) SecureString.new arguments changed to work with ruby 1.8.
+                        Instead of specifying the argument type hint first, you now do that with an options hash.
+                        (You will get a descriptive error if you try to do it the old way.)
 [1.2.1 - 2011-Jun-15] Bugfixes
                       * (FIX) To/From Base64 methods were returning normal strings, making chaining impossible.
 [1.2.0 - 2011-May-17] Re-wrote Base64 module to address problems with RFC 2045 vs. RFC 4648 compatibility.

data/lib/secure_string.rb

@@ -1,4 +1,4 @@
-require_relative 'securize_string'
+require File.join(File.dirname(__FILE__), 'securize_string')
 
 # SecureString is a String subclass whose emphasis is on byte data rather than
 # human readable strings. class gives a number of conveniences, such
@@ -12,9 +12,11 @@ class SecureString < String
   # [:hex] Initialize using a hexidecimal string.
   # [:int] Initialize using the numeric value of the hexidecimal string.
   # [:base64] Initialize using the given base64 encoded data.
-  def initialize(mode = :data, value)
-    data_string = self.class.parse_data(mode, value)
-    self.replace( data_string )
+  # To specify a value kind, pass the :type option.
+  def initialize(value, opts={})
+    raise ArgumentError, "The first argument is a symbol; setting the input data type this way is no longer supported. Call `#{self.class.name}.new('string', :type => #{value.inspect})' instead.", caller if value.kind_of?(Symbol)
+    data_string = self.class.parse_data(value, opts)
+    self.replace(data_string)
   end
   
   # Override the default to_i method to return the integer value of the data

data/lib/securize_string/base64_methods.rb

@@ -25,7 +25,7 @@ module SecurizeString
       # removed from the input.
       def to_base64(opts={})
         raise ArgumentError, "__method__ expects an argument hash but got #{opts.class.name}" unless opts.kind_of?(Hash)
-        data = (opts[:url_safe] ? Base64.urlsafe_encode64(self) : Base64.encode64(self))
+        data = (opts[:url_safe] ? urlsafe_encode64(self) : Base64.encode64(self))
         data.delete!("\n\r") if opts[:no_break] # Delete on \n and \r is about 3x faster than gsub on /\s+/.
         return self.class.new(data)
       end
@@ -39,10 +39,42 @@ module SecurizeString
       # which is sometimes compatible, but often incompatible with RFC 2045.
       def from_base64(opts={})
         raise ArgumentError, "__method__ expects an argument hash but got #{opts.class.name}" unless opts.kind_of?(Hash)
-        string = (opts[:url_safe] ? Base64.urlsafe_decode64(self) : Base64.decode64(self))
+        string = (opts[:url_safe] ? urlsafe_decode64(self) : Base64.decode64(self))
         return self.class.new(string)
       end
       
+      private
+      
+      # URL Safe encoding.
+      #
+      # Ruby 1.8 does not ship with this method, so we emulate it as best we
+      # can if it is missing.
+      def urlsafe_encode64(str)
+        if( Base64.respond_to?(:urlsafe_encode64) )
+          return Base64.urlsafe_encode64(str)
+        else
+          # This *should* work out the same.
+          return Base64.encode64(str).delete!("\n\r").tr("+/", "-_")
+        end
+      end
+      
+      # URL Safe decoding.
+      #
+      # Ruby 1.8 does not ship with this method, so we emulate it as best we
+      # can if it is missing.
+      def urlsafe_decode64(str)
+        if( Base64.respond_to?(:urlsafe_decode64) )
+          return Base64.urlsafe_decode64(str)
+        else
+          # To emulate the 1.9.2 strictness check, if we have any illegal characters, throw
+          # the same error that 1.9.2 does.
+          # Note that we can take characters from before and after the tr substitution fine.
+          # a-z, A-Z, 0-9, -, _, +, and / are valid characters
+          raise ArgumentError, "invalid base64" if str =~ /[^-a-zA-Z0-9_+\/]/
+          return Base64.decode64( str.tr("-_", "+/") )
+        end
+      end
+      
     end
     
   end

data/lib/securize_string/binary_string_data_methods.rb

@@ -18,17 +18,22 @@ module SecurizeString
       # [:hex] Initialize using a hexidecimal string.
       # [:int] Initialize using the numeric value of the hexidecimal string.
       # [:base64] Initialize using the given base64 encoded data.
-      def parse_data(mode = :data, value)
-        case mode
+      # To specify a value kind, use the :type option.
+      def parse_data(value, opts={})
+        raise ArgumentError, "The first argument is a symbol; setting the input data type this way is no longer supported. Call `#{self.class.name}.new('string', :type => #{value.inspect})' instead.", caller if value.kind_of?(Symbol)
+        data_type_hint = (opts[:data_type_hint] || opts[:type] || :data).to_sym
+        case data_type_hint
         when :hex
           hex_string = value.to_s.delete('^0-9a-fA-F')
           data_string = [hex_string].pack('H' + hex_string.bytesize.to_s)
         when :data
           data_string = value.to_s
         when :int
-          data_string = self.send(__method__, :hex, value.to_i.to_s(16))
+          data_string = self.send(__method__, value.to_i.to_s(16), :type => :hex)
         when :base64
           data_string = Base64.decode64(value.to_s)
+        else
+          raise ArgumentError, "Unrecognized data type hint: #{data_type_hint.inspect}"
         end
         
         return data_string

data/lib/securize_string/digest_methods.rb

@@ -1,5 +1,5 @@
 require 'openssl'
-require_relative 'digest_finder'
+require File.join(File.dirname(__FILE__), 'digest_finder')
   
 module SecurizeString
   # Adds methods for OpenSSL::Digest support.

data/lib/securize_string.rb

@@ -1,8 +1,12 @@
-require_relative 'securize_string/binary_string_data_methods'
-require_relative 'securize_string/digest_methods'
-require_relative 'securize_string/base64_methods'
-require_relative 'securize_string/cipher_methods'
-require_relative 'securize_string/rsa_methods'
+[
+  'binary_string_data_methods',
+  'digest_methods',
+  'base64_methods',
+  'cipher_methods',
+  'rsa_methods'
+].each do |module_file_name|
+  require File.join(File.dirname(__FILE__), 'securize_string', module_file_name)
+end
 
 module SecurizeString
   

data/spec/base64_methods_spec.rb

@@ -19,8 +19,10 @@ describe "SecureString" do
     it 'should convert self to Base64; URL safe' do
       @messages.each do |message|
         ss = SecureString.new(message[:string])
-        # Compare the result with the base ruby methods.
-        ss.to_base64(:url_safe => true).should == Base64.urlsafe_encode64(message[:string])
+        # If the version of ruby has :urlsafe_encode64, then we dynamically build to
+        # make sure the implementation hasn't changed; otherwise use the pre-cached string.
+        urlsafe_string = (Base64.respond_to?(:urlsafe_encode64)) ? Base64.urlsafe_encode64(message[:string]) : message[:urlsafe_base64]
+        ss.to_base64(:url_safe => true).should == urlsafe_string
       end
     end
     

data/spec/cipher_methods_spec.rb

@@ -59,10 +59,10 @@ describe "SecureString" do
       
       before(:all) do
         @cipher = "DES"
-        @key = SecureString.new(:hex, "4f42383e091ffc44")
-        @iv = SecureString.new(:hex, "0b9299d6c2cb5003")
+        @key = SecureString.new("4f42383e091ffc44", :type => :hex)
+        @iv = SecureString.new("0b9299d6c2cb5003", :type => :hex)
         @message = SecureString.new("We the People of the United States, in Order to form a more perfect Union, establish Justice, insure domestic Tranquility, provide for the common defence, promote the general Welfare, and secure the Blessings of Liberty to ourselves and our Posterity, do ordain and establish this Constitution for the United States of America.")
-        @encoded_message = SecureString.new(:hex, "cfe8245b2c1f3f789b8ab78930c9582d1fead6792d8fe7efd418ba06d7da4e96f8525e8b437cf29af71ec66801c2031292fc17d88f5aaa9c776b3ca048169b48394e05d5ae6cbba5c78461a25bc3d5abc646f5f760e3a159b8448d79eed80a209473ca67536ebf417a24f05cf029e9e3ca5b1fb22e4e03427705d79b622d720c7d64cf3621319581a1a89b4cbb630611eea29cbd2c48caef0cf774ea0218b16d600cb4c025dcae177b702040bd7c62569bbda33f8e775dbadba4154074f482385c56449882efa31b908dfe5be17d8c0d220fd99414a78f6ce3cfee007fbd5dfc7fd50c343e6118d1a9174bb75db7c5adbaa558010f56571d087982ae791960c31041bae08adfa4d1a88f457897e38bd56a7e92234d21c8742fa577878b2d65500877d2f910d1fdbb5460afa73642778de8bd4442981baa93a481482f1cfb90fa85025ddf8588ecc7")
+        @encoded_message = SecureString.new("cfe8245b2c1f3f789b8ab78930c9582d1fead6792d8fe7efd418ba06d7da4e96f8525e8b437cf29af71ec66801c2031292fc17d88f5aaa9c776b3ca048169b48394e05d5ae6cbba5c78461a25bc3d5abc646f5f760e3a159b8448d79eed80a209473ca67536ebf417a24f05cf029e9e3ca5b1fb22e4e03427705d79b622d720c7d64cf3621319581a1a89b4cbb630611eea29cbd2c48caef0cf774ea0218b16d600cb4c025dcae177b702040bd7c62569bbda33f8e775dbadba4154074f482385c56449882efa31b908dfe5be17d8c0d220fd99414a78f6ce3cfee007fbd5dfc7fd50c343e6118d1a9174bb75db7c5adbaa558010f56571d087982ae791960c31041bae08adfa4d1a88f457897e38bd56a7e92234d21c8742fa577878b2d65500877d2f910d1fdbb5460afa73642778de8bd4442981baa93a481482f1cfb90fa85025ddf8588ecc7", :type => :hex)
       end
       
       it 'should encode to a SecureString' do
@@ -88,10 +88,10 @@ describe "SecureString" do
     describe "AES" do
       
       before(:all) do
-        @key = SecureString.new(:hex, "83f8577c1bc406e85ceeebc166c9fd4d087670de792b0d957c58f1beae6fb514")
-        @iv = SecureString.new(:hex, "778c1086b5daf809e7abadde6995219d")
+        @key = SecureString.new("83f8577c1bc406e85ceeebc166c9fd4d087670de792b0d957c58f1beae6fb514", :type => :hex)
+        @iv = SecureString.new("778c1086b5daf809e7abadde6995219d", :type => :hex)
         @message = SecureString.new("We the People of the United States, in Order to form a more perfect Union, establish Justice, insure domestic Tranquility, provide for the common defence, promote the general Welfare, and secure the Blessings of Liberty to ourselves and our Posterity, do ordain and establish this Constitution for the United States of America.")
-        @encoded_message = SecureString.new(:hex, "1fee4d01d33daf50915dc4b7aaf8b536f3b19ee9798b21200d475925460fd3aabc581d89e560b7b826e6017e02911687425d9c4a781d8e03a9d75dab5a85191f86b11fb74063133c3952201a8f2089afb0e298e29fe8becbe93ce110073b9abb968a268857aaabd94caa760fa402ce803f8643ad8870e77714b093e9ea09a4ad9d7e056836939f614a61f6b3e09057bc05f13432aa53cfc7de59d41a121f9fcb7c51825da2615c48debff6ed0fbaa0c85594aef54e11b73b8766f6e56d2cf7488909c14272e846cccca0008599bae334c5d404c122d286dcf04eec7b7711978686a66182f53e569297b91c25100ecfdad1f02de444c4de8f9d04067e885a2a17cad707b51ea8c2e8a15051138de617f8864cca8a4d201246a97b95cee5f78f742aace79629e03498f63b6385cff64d53a0425f7f52c6a8ba65771e043590b61191804fe91760e617412d842831928e57")
+        @encoded_message = SecureString.new("1fee4d01d33daf50915dc4b7aaf8b536f3b19ee9798b21200d475925460fd3aabc581d89e560b7b826e6017e02911687425d9c4a781d8e03a9d75dab5a85191f86b11fb74063133c3952201a8f2089afb0e298e29fe8becbe93ce110073b9abb968a268857aaabd94caa760fa402ce803f8643ad8870e77714b093e9ea09a4ad9d7e056836939f614a61f6b3e09057bc05f13432aa53cfc7de59d41a121f9fcb7c51825da2615c48debff6ed0fbaa0c85594aef54e11b73b8766f6e56d2cf7488909c14272e846cccca0008599bae334c5d404c122d286dcf04eec7b7711978686a66182f53e569297b91c25100ecfdad1f02de444c4de8f9d04067e885a2a17cad707b51ea8c2e8a15051138de617f8864cca8a4d201246a97b95cee5f78f742aace79629e03498f63b6385cff64d53a0425f7f52c6a8ba65771e043590b61191804fe91760e617412d842831928e57", :type => :hex)
       end
       
       it 'should encode to a SecureString' do

data/spec/example_spec.rb

@@ -12,10 +12,10 @@ describe "Examples" do
     ss.to_i.should == 22405534230753928650781647905
     ss.to_base64.should == "SGVsbG8gV29ybGQh\n"
     
-    ss1 = SecureString.new(:data, "Hello World!")
-    ss2 = SecureString.new(:hex, "48656c6c6f20576f726c6421")
-    ss3 = SecureString.new(:int, 22405534230753928650781647905)
-    ss4 = SecureString.new(:base64, "SGVsbG8gV29ybGQh")
+    ss1 = SecureString.new("Hello World!", :type => :data)
+    ss2 = SecureString.new("48656c6c6f20576f726c6421", :type => :hex)
+    ss3 = SecureString.new(22405534230753928650781647905, :type => :int)
+    ss4 = SecureString.new("SGVsbG8gV29ybGQh", :type => :base64)
     
     ss1.should == ss
     ss2.should == ss
@@ -26,9 +26,9 @@ describe "Examples" do
   it 'should perform the base64 example' do
     SecureString.new("Hello World!").to_base64.should == "SGVsbG8gV29ybGQh\n"
     
-    (SecureString.new(:base64, "SGVsbG8gV29ybGQh") == "Hello World!"   ).should be_true
-    (SecureString.new("SGVsbG8gV29ybGQh") == "Hello World!"            ).should be_false
-    (SecureString.new("SGVsbG8gV29ybGQh").from_base64 == "Hello World!").should be_true
+    (SecureString.new("SGVsbG8gV29ybGQh", :type => :base64) == "Hello World!").should be_true
+    (SecureString.new("SGVsbG8gV29ybGQh") == "Hello World!"                  ).should be_false
+    (SecureString.new("SGVsbG8gV29ybGQh").from_base64 == "Hello World!"      ).should be_true
   end
   
   it 'should perform digest example' do
@@ -54,22 +54,24 @@ describe "Examples" do
     cipher_text.should_not == message
   end
   
-  it 'should perform the char encoding example' do
-    s = "Resum\u00E9"
-    s.encoding.should == Encoding.find("UTF-8")
-    s.length.should == 6
-    s.bytesize.should == 7
+  if( RUBY_VERSION >= '1.9.0' )
+    it 'should perform the char encoding example' do
+      s = "Resum\u00E9"
+      s.encoding.should == Encoding.find("UTF-8")
+      s.length.should == 6
+      s.bytesize.should == 7
     
-    s = "Resum\u00E9"
-    s.force_encoding('BINARY')
-    s.encoding.should == Encoding.find("ASCII-8BIT")
-    s.length.should == 7
-    s.bytesize.should == 7
+      s = "Resum\u00E9"
+      s.force_encoding('BINARY')
+      s.encoding.should == Encoding.find("ASCII-8BIT")
+      s.length.should == 7
+      s.bytesize.should == 7
     
-    s = "Resum\u00E9"
-    b = s.dup.force_encoding('BINARY')
-    (s == b).should be_false
-    (s.bytes.to_a == b.bytes.to_a).should be_true
+      s = "Resum\u00E9"
+      b = s.dup.force_encoding('BINARY')
+      (s == b).should be_false
+      (s.bytes.to_a == b.bytes.to_a).should be_true
+    end
   end
   
 end

data/spec/secure_string_spec.rb

@@ -22,31 +22,31 @@ describe "SecureString" do
   
   it 'should initialize from hex' do
     @messages.each do |message| 
-      ss = SecureString.new(:hex, message[:hex])
+      ss = SecureString.new(message[:hex], :type => :hex)
       ss.should == message[:string]
     
-      ss = SecureString.new(:hex, message[:hex].upcase)
+      ss = SecureString.new(message[:hex].upcase, :type => :hex)
       ss.should == message[:string]
     end
   end
   
   it 'should initialize from data' do
     @messages.each do |message|
-      ss = SecureString.new(:data, message[:string])
+      ss = SecureString.new(message[:string], :type => :data)
       ss.should == message[:string]
     end
   end
   
   it 'should initialize from int' do
     @messages.each do |message|
-      ss = SecureString.new(:int, message[:int])
+      ss = SecureString.new(message[:int], :type => :int)
       ss.should == message[:string]
     end
   end
   
   it 'should initialize from Base64' do
     @messages.each do |message|
-      ss = SecureString.new(:base64, message[:base64])
+      ss = SecureString.new(message[:base64], :type => :base64)
       ss.should == message[:string]
     end
     
@@ -59,7 +59,11 @@ describe "SecureString" do
   end
   
   it 'should implement to_hex' do
-    SecureString.instance_methods.should include(:to_hex)
+    if( RUBY_VERSION >= '1.9.0' )
+      SecureString.instance_methods.should include(:to_hex)
+    else
+      SecureString.instance_methods.should include('to_hex')
+    end
     
     @messages.each do |message|
       ss = SecureString.new(message[:string])
@@ -68,7 +72,11 @@ describe "SecureString" do
   end
   
   it 'should implement to_i properly' do
-    SecureString.instance_methods.should include(:to_i)
+    if( RUBY_VERSION >= '1.9.0' )
+      SecureString.instance_methods.should include(:to_i)
+    else
+      SecureString.instance_methods.should include('to_i')
+    end
     
     @messages.each do |message|
       ss = SecureString.new(message[:string])
@@ -89,7 +97,7 @@ describe "SecureString" do
     35563e0d 8bdf572f 77b53065 cef31f32 dc9dbaa0 4146261e 9994bd5c d0758e3d"
     DATA
     
-    ss = SecureString.new(:hex, data)
+    ss = SecureString.new(data, :type => :hex)
     
     # This was taken from a publically published SHA-0 data collision document,
     # so the best way to know that the data is good is to SHA-0 it and see if
@@ -97,33 +105,35 @@ describe "SecureString" do
     OpenSSL::Digest::SHA.hexdigest(ss).should == "c9f160777d4086fe8095fba58b7e20c228a4006b"
   end
   
-  describe 'Encodings' do
+  if( RUBY_VERSION >= '1.9.0' )
+    describe 'Encodings' do
     
-    before(:each) do
-      @unicode_string = "A resumé for the moose; Eine Zusammenfassung für die Elche; Резюме для лосей; アメリカヘラジカのための概要; Μια περίληψη για τις άλκες; 麋的一份簡歷; Un résumé pour les orignaux."
-    end
+      before(:each) do
+        @unicode_string = "A resumé for the moose; Eine Zusammenfassung für die Elche; Резюме для лосей; アメリカヘラジカのための概要; Μια περίληψη για τις άλκες; 麋的一份簡歷; Un résumé pour les orignaux."
+      end
     
-    it 'should NOT change the encoding of a string' do
-      @unicode_string.encoding.should == Encoding.find("UTF-8")
-      ss = SecureString.new(@unicode_string)
-      ss.encoding.should == @unicode_string.encoding
-    end
+      it 'should NOT change the encoding of a string' do
+        @unicode_string.encoding.should == Encoding.find("UTF-8")
+        ss = SecureString.new(@unicode_string)
+        ss.encoding.should == @unicode_string.encoding
+      end
     
-    it 'should NOT change the length to the byte count for UTF-8 encoded strings.' do
-      @unicode_string.encoding.should == Encoding.find("UTF-8")
-      ss = SecureString.new(@unicode_string)
-      ss.length.should < ss.bytesize
-    end
+      it 'should NOT change the length to the byte count for UTF-8 encoded strings.' do
+        @unicode_string.encoding.should == Encoding.find("UTF-8")
+        ss = SecureString.new(@unicode_string)
+        ss.length.should < ss.bytesize
+      end
     
-    it 'should allow forced transcoding to binary' do
-      ss = SecureString.new(@unicode_string)
+      it 'should allow forced transcoding to binary' do
+        ss = SecureString.new(@unicode_string)
       
-      ss.encoding.should == Encoding.find("UTF-8")
-      ss.force_encoding("Binary")
-      ss.encoding.should == Encoding.find("ASCII-8BIT")
-      @unicode_string.encoding.should == Encoding.find("UTF-8")
-    end
+        ss.encoding.should == Encoding.find("UTF-8")
+        ss.force_encoding("Binary")
+        ss.encoding.should == Encoding.find("ASCII-8BIT")
+        @unicode_string.encoding.should == Encoding.find("UTF-8")
+      end
     
+    end
   end
   
 end

data/spec/spec_helper.rb

@@ -8,14 +8,16 @@ MESSAGES = [
     :string => "Hello",
     :hex => "48656c6c6f",
     :int => 310939249775,
-    :base64 => "SGVsbG8=" # Leave off the \n on purpose so that we can make sure it handles that case appropriately when instantiating using base64.
+    :base64 => "SGVsbG8=", # Leave off the \n on purpose so that we can make sure it handles that case appropriately when instantiating using base64.
+    :urlsafe_base64 => "SGVsbG8="
   },
   
   {
     :string => "This is a test of the emergency broadcast system; this is only a test.",
     :hex => "5468697320697320612074657374206f662074686520656d657267656e63792062726f6164636173742073797374656d3b2074686973206973206f6e6c79206120746573742e",
     :int => 1244344095146357680190496293767338268850834164562379171846588371816488740307922111470765515885864931093899586331709567338989540039042962957732585272476408412061178229806,
-    :base64 => "VGhpcyBpcyBhIHRlc3Qgb2YgdGhlIGVtZXJnZW5jeSBicm9hZGNhc3Qgc3lz\ndGVtOyB0aGlzIGlzIG9ubHkgYSB0ZXN0Lg==\n"
+    :base64 => "VGhpcyBpcyBhIHRlc3Qgb2YgdGhlIGVtZXJnZW5jeSBicm9hZGNhc3Qgc3lz\ndGVtOyB0aGlzIGlzIG9ubHkgYSB0ZXN0Lg==\n",
+    :urlsafe_base64 => "VGhpcyBpcyBhIHRlc3Qgb2YgdGhlIGVtZXJnZW5jeSBicm9hZGNhc3Qgc3lzdGVtOyB0aGlzIGlzIG9ubHkgYSB0ZXN0Lg=="
   },
   
   # This one tests a special case where url safe encodes differently than the standard.
@@ -23,6 +25,7 @@ MESSAGES = [
     :string => "HI?",
     :hex => "48493f",
     :int => 4737343,
-    :base64 => "SEk/\n"
+    :base64 => "SEk/\n",
+    :urlsafe_base64 => "SEk_"
   }
 ].freeze

metadata

@@ -2,7 +2,7 @@
 name: secure_string
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors: 
 - Jeff Reinecke
@@ -55,7 +55,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: 1.9.0
+      version: 1.8.6
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: