secure_string 1.0.0 → 1.1.0

data/README.rdoc

@@ -21,6 +21,43 @@ measure of a byte string's length, as depending on the encoding, it may count
 multibyte characters as a single element.  To ensure that you get the byte
 length, use the standard string method +bytesize+.
 
+= Installation & Configuration
+
+== Installation
+
+Install from gem, and add the following to your script:
+
+  require 'secure_string'
+
+By default, this creates the SecureString class, which is completely configured
+and ready to go like so:
+
+  SecureString.new("foo")
+
+== Optional Configuration
+
+Some people like to monkey patch String to translate to a
+SecureString like so:
+
+  # This is an optional configuration:
+  class String
+    def to_ss
+      return SecureString.new(self)
+    end
+  end
+
+Alternatively, if you would like to add the SecureString methods directly onto
+all Strings, simply add the following code to your program:
+
+  # This is an optional configuration:
+  class String
+    include SecurizeString
+  end
+
+Unless you already have code that modifies String in a conflicting way--or code
+that depends on the value of +inspect+, this should not change the behavior of
+your existing code.
+
 = Examples
 
 == Basic Usage
@@ -142,6 +179,8 @@ or directly via e-mail at:
 mailto:jeff@paploo.net
 
 = Version History
+[1.1.0 - 2030-Nov-04] Extracted methods into a module that can be easily included
+                      on any String class.
 [1.0.0 - 2010-Nov-04] Added Tests, Examples, and Bugfixes
                       * Added a full suite of spec tests.
                       * (FEATURE) Can get a list of supported ciphers.
@@ -154,9 +193,6 @@ mailto:jeff@paploo.net
                       
 = TODO List
 
-* Add complete spec tests.
-* Add examples.
-* Pull out all methods into modules so that it can be an extension of all Strings.
 * Add a +to_ss+ or +to_secure+ method to String for easy conversion.
 * to_digest should be able to take a string that is the algorithm name.
 * Explore how encodings affect the data.  What about when finding length?  What

data/lib/secure_string.rb

@@ -1,19 +1,11 @@
-require 'base64'
-
-require_relative 'secure_string/digest_methods'
-require_relative 'secure_string/base64_methods'
-require_relative 'secure_string/cipher_methods'
-require_relative 'secure_string/rsa_methods'
+require_relative '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
 # as  easier viewing of the byte data as hex, digest methods, and encryption
 # and decryption methods.
 class SecureString < String
-  include Base64Methods
-  include DigestMethods
-  include RSAMethods
-  include CipherMethods
+  include SecurizeString
   
   # Creates the string from one many kinds of values:
   # [:data] (default) The passed string value is directly used.
@@ -21,39 +13,8 @@ class SecureString < String
   # [:int] Initialize using the numeric value of the hexidecimal string.
   # [:base64] Initialize using the given base64 encoded data.
   def initialize(mode = :data, value)
-    case mode
-    when :hex
-      hex_string = value.to_s
-      data = [hex_string].pack('H' + hex_string.length.to_s)
-    when :data
-      data = value.to_s
-    when :int
-      data = self.send(__method__, :hex, value.to_i.to_s(16))
-    when :base64
-      data = Base64.decode64(value.to_s)
-    end
-    
-    self.replace(data)
-  end
-  
-  # Override the default String inspect to return the hexidecimal
-  # representation of the data contained in this string.
-  def inspect
-    return "<#{to_hex}>"
-  end
-  
-  # Returns the hexidecimal string representation of the data.
-  def to_hex
-    return (self.empty? ? '' : self.unpack('H' + (self.length*2).to_s)[0])
-  end
-  
-  # Returns the data converted from hexidecimal into an integer.
-  # This is usually as a BigInt.
-  #
-  # WARNING: If the data string is empty, then this returns -1, as there is no
-  # integer representation of the absence of data.
-  def to_i
-    return (self.empty? ? -1 : to_hex.hex)
+    data_string = self.class.parse_data(mode, value)
+    self.replace( data_string )
   end
   
 end

data/lib/securize_string.rb

@@ -0,0 +1,21 @@
+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'
+
+module SecurizeString
+  
+  def self.included(mod)
+    [
+      BinaryStringDataMethods,
+      Base64Methods,
+      DigestMethods,
+      RSAMethods,
+      CipherMethods
+    ].each do |mixin|
+      mod.send(:include, mixin)
+    end
+  end
+  
+end

data/lib/{secure_string → securize_string}/base64_methods.rb

@@ -1,6 +1,6 @@
 require 'base64'
 
-class SecureString < String
+module SecurizeString
   # Adds methods for Base64 conversion.
   # See Base64Methods::InstanceMethods for more details.
   module Base64Methods
@@ -10,7 +10,7 @@ class SecureString < String
     end
     
     # Adds instance methods for Base64 support via inclusion of
-    # SecureString::Base64Methods to a class.
+    # SecurizeString::Base64Methods to a class.
     module InstanceMethods
       
       # Encodes to Base64.  By default, the output is made URL safe, which means all

data/lib/securize_string/binary_string_data_methods.rb

@@ -0,0 +1,68 @@
+require 'base64'
+
+module SecurizeString
+  # Adds the base methods necessary to make String or a String subclass handle
+  # binary data better.
+  # See BinaryStringDataMethods::ClassMethods and BinaryStringDataMethods::InstanceMethods for more deatils.
+  module BinaryStringDataMethods
+    
+    def self.included(mod)
+      mod.send(:extend, ClassMethods)
+      mod.send(:include, InstanceMethods)
+    end
+    
+    # Adds basic binary data class methods to String or a String subclass, via
+    # an include of SecurizeString::BinaryStringDataMethods
+    module ClassMethods
+      
+      # Creates a data string from one many kinds of values:
+      # [:data] (default) The passed string value is directly used.
+      # [: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
+        when :hex
+          hex_string = value.to_s
+          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))
+        when :base64
+          data_string = Base64.decode64(value.to_s)
+        end
+        
+        return data_string
+      end
+      
+    end
+    
+    # Adds basic binary data instance methods to String or a String subclass, via
+    # an include of SecurizeString::BinaryStringDataMethods.
+    module InstanceMethods
+      
+      # Override the default inspect to return the hexidecimal
+      # representation of the data contained in this string.
+      def inspect
+        return "<#{to_hex}>"
+      end
+      
+      # Returns the hexidecimal string representation of the data.
+      def to_hex
+        return (self.to_s.empty? ? '' : self.to_s.unpack('H' + (self.to_s.bytesize*2).to_s)[0])
+      end
+      
+      # Returns the data converted from hexidecimal into an integer.
+      # This is usually as a BigInt.
+      #
+      # WARNING: If the data string is empty, then this returns -1, as there is no
+      # integer representation of the absence of data.
+      def to_i
+        return (self.to_s.empty? ? -1 : to_hex.hex)
+      end
+      
+    end
+    
+  end
+end

data/lib/{secure_string → securize_string}/cipher_methods.rb

@@ -1,6 +1,6 @@
 require 'openssl'
 
-class SecureString < String
+module SecurizeString
   # Adds methods for OpenSSL::Cipher support including AES encryption.
   # See CipherMethods::ClassMethods and CipherMethods::InstanceMethods for more details.
   module CipherMethods
@@ -11,7 +11,7 @@ class SecureString < String
     end
     
     # Adds class methods for OpenSSL::Cipher support, including AES encryption,
-    # via inclusion of SecureString::CipherMethods into a class.
+    # via inclusion of SecurizeString::CipherMethods into a class.
     module ClassMethods
       
       # Returns a list of supported ciphers.  These can be passed directly into
@@ -37,7 +37,7 @@ class SecureString < String
     end
     
     # Adds instance methods for OpenSSL::Cipher support, including AES encryption,
-    # via inclusion of SecureString::CipherMethods into a class.
+    # via inclusion of SecurizeString::CipherMethods into a class.
     module InstanceMethods
       
       # Given an OpenSSL cipher name, a key, and initialization vector,

data/lib/{secure_string → securize_string}/digest_methods.rb

@@ -1,6 +1,6 @@
 require 'openssl'
   
-class SecureString < String
+module SecurizeString
   # Adds methods for OpenSSL::Digest support.
   # See DigestMethods::ClassMethods and DigestMethods::InstanceMethods for more details.
   module DigestMethods
@@ -10,7 +10,7 @@ class SecureString < String
     end
     
     # Adds instance methods for OpenSSL::Digest support via inclusion of
-    # SecureString::DigestMethods to a class.
+    # SecurizeString::DigestMethods to a class.
     module InstanceMethods
       
       # Returns the digest of the byte string as a SecureString, using the passed OpenSSL object.

data/lib/{secure_string → securize_string}/rsa_methods.rb

@@ -1,6 +1,6 @@
 require 'openssl'
 
-class SecureString < String
+module SecurizeString
   # Adds methods for OpenSSL::PKey::RSA support.
   # See RSAMethods::ClassMethods and RSAMethods::InstanceMethods for more details.
   module RSAMethods
@@ -11,7 +11,7 @@ class SecureString < String
     end
     
     # Adds class methods for OpenSSL::PKey::RSA support via inclusion of
-    # SecureString::RSAMethods to a class.
+    # SecurizeString::RSAMethods to a class.
     module ClassMethods
       
       # A convenience method for generating random public/private RSA key pairs.
@@ -35,7 +35,7 @@ class SecureString < String
     end
     
     # Adds instance methods for OpenSSL::PKey::RSA support via inclusion of
-    # SecureString::RSAMethods to a class.
+    # SecurizeString::RSAMethods to a class.
     module InstanceMethods
       
       # Given an RSA public key, it RSA encrypts the data string.

data/spec/binary_string_data_methods_spec.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "SecurityString" do
+  
+  before(:all) do
+    @messages = MESSAGES
+  end
+  
+  describe "Binary String Data Methods" do
+  
+    it 'should be able to convert to a hex string' do
+      @messages.each do |message|
+        ss = SecureString.new(message[:string])
+        ss.to_hex.should == message[:hex]
+      end
+    end
+  
+    it 'should be able to convert to an int value' do
+      @messages.each do |message|
+        ss = SecureString.new(message[:string])
+        ss.to_i.should == message[:int]
+      end
+    end
+  
+    it 'should output like a string for to_s' do
+      @messages.each do |message|
+        s = String.new(message[:string])
+        ss = SecureString.new(message[:string])
+        ss.to_s.should == s.to_s
+      end
+    end
+  
+    it 'should output the hex value with inspect' do
+      @messages.each do |message|
+        s = String.new(message[:string])
+        ss = SecureString.new(message[:string])
+        ss.inspect.should include(ss.to_hex)
+        ss.inspect.should_not include(s.to_s)
+      end
+    end
+    
+  end
+  
+end

data/spec/secure_string_spec.rb

@@ -56,35 +56,4 @@ describe "SecureString" do
     newline_count.select {|nl_count| nl_count > 1}.should_not be_empty
   end
   
-  it 'should be able to convert to a hex string' do
-    @messages.each do |message|
-      ss = SecureString.new(message[:string])
-      ss.to_hex.should == message[:hex]
-    end
-  end
-  
-  it 'should be able to convert to an int value' do
-    @messages.each do |message|
-      ss = SecureString.new(message[:string])
-      ss.to_i.should == message[:int]
-    end
-  end
-  
-  it 'should output like a string for to_s' do
-    @messages.each do |message|
-      s = String.new(message[:string])
-      ss = SecureString.new(message[:string])
-      ss.to_s.should == s.to_s
-    end
-  end
-  
-  it 'should output the hex value with inspect' do
-    @messages.each do |message|
-      s = String.new(message[:string])
-      ss = SecureString.new(message[:string])
-      ss.inspect.should include(ss.to_hex)
-      ss.inspect.should_not include(s.to_s)
-    end
-  end
-  
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
+  - 1
   - 0
-  - 0
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Jeff Reinecke
@@ -30,12 +30,15 @@ files:
 - README.rdoc
 - LICENSE.txt
 - Rakefile
-- lib/secure_string/base64_methods.rb
-- lib/secure_string/cipher_methods.rb
-- lib/secure_string/digest_methods.rb
-- lib/secure_string/rsa_methods.rb
 - lib/secure_string.rb
+- lib/securize_string/base64_methods.rb
+- lib/securize_string/binary_string_data_methods.rb
+- lib/securize_string/cipher_methods.rb
+- lib/securize_string/digest_methods.rb
+- lib/securize_string/rsa_methods.rb
+- lib/securize_string.rb
 - spec/base64_methods_spec.rb
+- spec/binary_string_data_methods_spec.rb
 - spec/cipher_methods_spec.rb
 - spec/digest_methods_spec.rb
 - spec/rsa_methods_spec.rb