shredder 0.2.0 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 86de11dca31147b96703885615c3727a7256bda2
+  data.tar.gz: 10147305bd2892e76a56b5ad8378f52470c4be5d
+SHA512:
+  metadata.gz: 5f19a35eb7ba38592f328f0d87e93401ae528b470c6046d81ace2d4b0dfbaf1db2e8a07df8d41a2a2e86091d7969d52e51889d78988037cc53c71b3d7aeb83a4
+  data.tar.gz: cfb6ccd2fcecd29df7a02c24caba969a06e7025ea8b82c2af782d1aa5a2c994c1eb2dff806e0e31169c426ae904ef07af6bb90c1f9c015c17e759fbd010f7ac0

data/README.rdoc

@@ -0,0 +1,58 @@
+= shredder
+
+github :: https://www.github.com/carlosjhr64/shredder
+rubygems :: https://rubygems.org/gems/shredder
+
+== DESCRIPTION:
+
+Shred a file into file fragments, and join fragments back into a restored file.
+
+Disperse file shreds in separate depositories
+so that no one depository has the entire file.
+
+== SYNOPSIS
+
+Command line:
+
+   $ shredder --help
+   $ shredder --shred file.orig  file.1 file.2
+   $ shredder --sew   file.sewed file.1 file.2
+   $ cat file.orig | shredder --shred --io file.1 file.2
+   $ shredder --sew --io file.1 file.2 > file.sewed
+
+Library:
+
+   require 'shredder'
+   # ...
+   shredder = SHREDDER:Shredder.new
+   shredder.shred('orinal.txt', 'shred.1', 'shred.2')
+   shredder.sew(  'sewed.txt',  'shred.1', 'shred.2')
+
+== INSTALL:
+
+   $ sudo gem install shredder
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2014 CarlosJHR64
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/TODO.txt

@@ -0,0 +1,7 @@
+== TODO
+
+Implement the --yes, --no, and --force options.
+
+== File List
+
+

data/bin/shredder

@@ -1,84 +1,43 @@
 #!/usr/bin/env ruby
-require 'shredder'
-raise "Need Shredder version ~> 0.1" if Shredder::VERSION < '0.1'
 
-# Command line utility
-class CommandLine
-  def self.version
-    puts Shredder::VERSION
-    exit(0)
-  end
+# Gems:
+require 'help_parser'
 
-  def self.help
-    puts <<EOT
-shredder      --shred sewed_file shred_file1 shred_file2...  # shred a file to shreds
-shredder --io --shred            shred_file1 shred_file2...  # shred stdin to shreds
-shredder      --sew   sewed_file shred_file1 shred_file2...  # sew shreds back to file
-shredder --io --sew              shred_file1 shred_file2...  # sew shreds out to stdout
-# --relay in sew mode will relay the first gets from stdin (used to pass on a passphrase to gpg, for example).
-EOT
-    print "# VERSION: "
-    CommandLine.version
-  end
+# This Gem:
+require 'shredder'
+include SHREDDER
 
-  def self.parse_argv
-    options = ''
-    while ARGV[0]=~/^-/ do
-      options += ARGV.shift
-    end
-    CommandLine.version if options =~ /-v\b/ || options =~ /--version\b/ # need to allow verbose below.
-    CommandLine.help if ARGV.length==0 || options =~ /-h/
-    $verbose = (options=~/--verbose\b/)? true : false
-    # validate
-    raise "--sew or --shred ?" if !(options=~/--sew\b/) && !(options=~/--shred\b/)
-    length = ARGV.length
-    raise "Expected sew shred1 shred2 ..."	if length < 2 && !(options=~/--io\b/)
-    raise "Expected shred1 shred2..."		if length < 1
-    return options
-  end
+NAME = File.basename $0 # Program Name
+HELP = <<HELP
+Usage: #{NAME} [options] [file] shred1 shred2...
+Options:
+  -r --shred     Shred a file to shreds.
+  -w --sew       Sew shreds back to file.
+  -s --io        Shreds/sews from/to stdin/stdout respectively.
+  --relay        Relay first stdin gets to stdout puts.
 
-  def initialize
-    options = CommandLine.parse_argv
-    @shredding = (options=~/--shred\b/)? true : false
-    @relay = (options=~/--relay\b/)? true : false
-    if options=~/--io/ then
-      if @shredding then
-        @sew = $stdin
-        @shreds = ARGV.map{|filename| File.open(filename,'w')} # WRITE SHREDS
-      else
-        @sew = $stdout
-        @shreds = ARGV.map{|filename| File.open(filename,'r')} # READ SHREDS
-      end
-    else
-      @sew = ARGV.shift
-      @shreds = ARGV
-    end
-  end
+  -h --help      Puts this help and exits.
+  -v --version   Puts version and exits.
 
-  def execute
-    shredder = (@sew.class == String)? Shredder::Files.new(@sew,@shreds): Shredder::Streams.new(@sew,@shreds)
-    begin
-      if @shredding then
-        shredder.shred
-      else
-        if @relay && (passphrase = $stdin.gets) then
-          # In a typical situation, we may be asked to relay a passphrase
-          $stdout.puts passphrase
-        end
-        shredder.sew
-      end
-    rescue StandardError
-      $stderr.puts $!
-      $stderr.puts $!.backtrace if $verbose
-    ensure
-      @shreds.each{|filehandle| filehandle.close}	if !(@sew.class == String)
-    end
-  end
-end
+  -f --force     These are not implemented yet,
+  --yes          but are defined to provide
+  --no           a symmetry with commands like gpg.
+Note:
+  Typical use of relay is for passphrase.
+Version: #{VERSION}
+HELP
 
 begin
-  CommandLine.new.execute
-rescue StandardError
-  $stderr.puts $!
-  $stderr.puts $!.backtrace if $verbose
+  OPTIONS = HELP_PARSER::HelpParser.new(VERSION, HELP)
+  OPTIONS.defaults!(:shred, false, true)
+  OPTIONS.defaults!(:sew,   false, true)
+  OPTIONS.usage_error "Need choice: sew or shred?" unless OPTIONS[:sew] ^ OPTIONS[:shred] # xor
+  MIN = (OPTIONS[:io])? 2 : 3
+  OPTIONS.usage_error "Need at least 2 shreds" unless ARGV.length >= MIN
+  Shredder.new(OPTIONS, ARGV).execute
+rescue HELP_PARSER::UsageException
+  puts $!.message
+rescue HELP_PARSER::UsageError
+  STDERR.puts $!.message
+  exit 64
 end

data/features/main.feature

@@ -0,0 +1,72 @@
+@main
+Feature: Main Features
+
+  Background:
+    * Given command "ruby -I ./lib ./bin/shredder"
+
+  Scenario: Long opt version.
+    * Given arguments "--version"
+    * When run
+    * Then status is "0"
+    * Then stderr is ""
+    * Then stdout is "1.0.0"
+
+  Scenario: Long opt help.
+    * Given arguments "--help"
+    * When run
+    * Then status is "0"
+    * Then stderr is ""
+    * Then stdout matches "^Usage: shredder"
+
+  Scenario: Can't be both sew and shred.
+    * Given system(rm ./temp.* 2> /dev/null)
+    * Given system(openssl rand -base64 32 > ./temp.txt)
+    * Given arguments "--sew --shred ./temp.txt ./temp.1 ./temp.2"
+    * When run
+    * Then status is "64"
+    * Then stderr is not ""
+    * Then stdout is ""
+    * Then stderr is "Need choice: sew or shred?"
+
+  Scenario: Needs to be either sew or shred.
+    * Given system(rm ./temp.* 2> /dev/null)
+    * Given system(openssl rand -base64 32 > ./temp.txt)
+    * Given arguments "./temp.txt ./temp.1 ./temp.2"
+    * When run
+    * Then status is "64"
+    * Then stderr is not ""
+    * Then stdout is ""
+    * Then stderr is "Need choice: sew or shred?"
+
+  Scenario: What we shred, we can sew.
+    * Given system(rm ./temp.* 2> /dev/null)
+    * Given system(openssl rand -base64 32 > ./temp.txt)
+    * Given arguments "--shred ./temp.txt ./temp.1 ./temp.2"
+    * When run
+    * Then status is "0"
+    * Then stderr is ""
+    * Then stdout is ""
+    * Then system(test -e ./temp.1)
+    * Then system(test -e ./temp.2)
+    * Given arguments "--sew ./temp.sewed ./temp.1 ./temp.2"
+    * When run
+    * Then status is "0"
+    * Then stderr is ""
+    * Then stdout is ""
+    * Then system(test -e ./temp.sewed)
+    # temp.txt and temp.sewed are equal
+    * Then system(diff temp.txt temp.sewed > /dev/null)
+    # Just a sanity check temp.1 and temp.2 are not equal
+    * Then not system(diff temp.1 temp.2 > /dev/null)
+
+  Scenario: What we shred from stdin, we can sew to stdout.  And using 3 shreds to boot!
+    * Given system(rm ./temp.* 2> /dev/null)
+    * Given system(openssl rand -base64 32 > ./temp.txt)
+    * Given system(cat ./temp.txt | ruby -I ./lib ./bin/shredder --shred --io ./temp.1 ./temp.2 ./temp.3)
+    * Then system(test -e ./temp.3)
+    * Given system(ruby -I ./lib ./bin/shredder --sew --io ./temp.1 ./temp.2 ./temp.3 > ./temp.sewed)
+    * Then system(test -e ./temp.sewed)
+    * Then system(diff temp.txt temp.sewed > /dev/null)
+
+    # Let's clean up after ourselves...
+    * Given system(rm ./temp.* 2> /dev/null)

data/features/step_definitions/main_steps.rb

@@ -0,0 +1,77 @@
+require 'open3'
+
+# Requires:
+#`bash`
+
+H = {}
+
+def _capture3(command)
+  stdout, stderr, status = Open3.capture3(command)
+  H['status'] = status.exitstatus
+  H['stdout'] = stdout.chomp
+  H['stderr'] = stderr.chomp
+end
+
+def _given(condition)
+  case condition
+  when /^(\w+) "([^"]*)"$/
+    H[$1] = $2
+  when /^system\(([^\(\)]*)\)$/
+    system($1)
+  else
+    raise "Unrecognized Given-Statement"
+  end
+end
+
+def _when(condition)
+  case condition
+  when 'run'
+    command, arguments = H['command'], H['arguments']
+    raise 'Need command and argurments to run' unless command and arguments
+    _capture3("#{command} #{arguments}")
+  when /^run\(([^\(\)]*)\)$/
+    _capture3($1)
+  else
+    raise "Unrecognized When-Statement"
+  end
+end
+
+def _then(condition)
+  case condition
+  when /^(not )?system\(([^\(\)]*)\)$/
+    neg, cmd = $1, $2
+    ok = system(cmd)
+    ok = !ok if neg
+    raise "System Call Error" unless ok
+  when /^(\w+) (\w+)( not)? "([^"]*)"$/
+    key, cmp, negate, expected = $1, $2, $3, $4
+    actual = H[key].to_s
+    ok = case cmp
+    when 'is'
+      actual == expected
+    when 'matches'
+      expected = Regexp.new(expected)
+      actual =~ expected
+    else
+      raise "Unrecognized Comparison Operator"
+    end
+    ok = !ok if negate
+    raise "Got #{actual} for #{key}" unless ok
+  else
+    raise "Unrecognized Then-Statement"
+  end
+end
+
+Given /^(\w+) (.*)$/ do |given, condition|
+  condition.strip!
+  case given
+  when 'Given'
+    _given(condition)
+  when 'When'
+    _when(condition)
+  when 'Then'
+    _then(condition)
+  else
+    raise "'#{given}' form not defined."
+  end
+end

data/lib/shredder.rb

@@ -1,35 +1,8 @@
-module Shredder
-  VERSION = '0.2.0'
+require 'shredder/version'
+require 'shredder/functions'
+require 'shredder/files'
+require 'shredder/streams'
+require 'shredder/shredder'
 
-  # note that these are streams
-  def self.shred(reader,writers,limit=0)
-    shreds = writers.length
-    xor = count = 0
-    while byte = reader.getbyte do
-      writers[ count % shreds ].putc byte^xor
-      xor = byte
-      count += 1
-      # note: will not break if limit is zero
-      break if count == limit
-    end
-    return count
-  end
-
-  # note that these are streams
-  def self.sew(writer,readers,limit=0)
-    shreds = readers.length
-    xor = count = 0
-    while byte = readers[ count % shreds ].getbyte do
-      chr = byte^xor
-      xor = chr
-      writer.putc chr
-      count += 1
-      # note: will not break if limit is zero
-      break if count == limit
-    end
-    return count
-  end
-
-  autoload :Files,	'shredder/files'
-  autoload :Streams,	'shredder/streams'
-end
+# Requires:
+#`ruby`

data/lib/shredder/files.rb

@@ -1,20 +1,23 @@
-module Shredder
+module SHREDDER
+
   class Files
+    extend Functions
+
      # this one takes filenames
-    def initialize(sew,shreds,limit=0)
-      @sew = sew
+    def initialize(sew, shreds, limit=0)
+      @sew    = sew
       @shreds = shreds
-      @limit = limit
+      @limit  = limit
     end
 
     def shred(limit=@limit)
-      reader = File.open(@sew,'r')
+      reader  = File.open(@sew, 'r')
       writers = []
-      @shreds.each{|shred| writers.push( File.open(shred,'wb') ) }
+      @shreds.each{|shred| writers.push(File.open(shred, 'wb'))}
 
       count = nil
       begin
-        count = Shredder.shred( reader, writers, limit )
+        count = Files.shred(reader, writers, limit)
       rescue Exception
         raise $!
       ensure
@@ -26,13 +29,13 @@ module Shredder
     end
 
     def sew(limit=@limit)
-      writer = File.open(@sew,'wb')
+      writer  = File.open(@sew, 'wb')
       readers = []
-      @shreds.each{|shred| readers.push( File.open(shred,'r') ) }
+      @shreds.each{|shred| readers.push(File.open(shred, 'r'))}
 
       count = nil
       begin
-        count = Shredder.sew( writer, readers, limit )
+        count = Files.sew(writer, readers, limit)
       rescue Exception
         raise $!
       ensure
@@ -42,5 +45,7 @@ module Shredder
 
       return count
     end
+
   end
+
 end

data/lib/shredder/functions.rb

@@ -0,0 +1,36 @@
+module SHREDDER
+
+  module Functions
+
+    # note that these are streams
+    def shred(reader, writers, limit=0)
+      shreds = writers.length
+      xor = count = 0
+      while byte = reader.getbyte do
+        writers[ count % shreds ].putc byte^xor
+        xor = byte
+        count += 1
+        # note: will not break if limit is zero
+        break if count == limit
+      end
+      return count
+    end
+
+    # note that these are streams
+    def sew(writer, readers, limit=0)
+      shreds = readers.length
+      xor = count = 0
+      while byte = readers[ count % shreds ].getbyte do
+        chr = byte^xor
+        xor = chr
+        writer.putc chr
+        count += 1
+        # note: will not break if limit is zero
+        break if count == limit
+      end
+      return count
+    end
+
+  end
+
+end

data/lib/shredder/shredder.rb

@@ -0,0 +1,46 @@
+module SHREDDER
+
+  class Shredder
+
+    attr_reader :shreds, :sewed
+    def initialize(options={}, shreds=[], sewed=nil)
+      @shreds, @sewed = shreds, sewed
+      @shred = options[:shred]
+      @relay = options[:relay]
+      if @sewed.nil?
+        if options[:io]
+          @sewed = (@shred)? STDIN : STDOUT
+        else
+          @sewed = @shreds.shift
+        end
+      end
+    end
+
+    def execute(sewed=@sewed, shreds=@shreds, shred=@shred)
+      stream = false
+      if sewed.kind_of?(IO)
+        stream = true
+        rw     = (shred)? 'w' : 'r'
+        shreds = shreds.map{|filename| File.open(filename, rw)}
+      end
+
+      shredder = (stream)? Shredder::Streams.new(sewed, shreds) : Shredder::Files.new(sewed, shreds)
+      STDOUT.puts STDIN.gets if @relay
+      begin
+        (shred)? shredder.shred : shredder.sew
+      ensure
+        shreds.each{|filehandle| filehandle.close} if stream
+      end
+    end
+
+    def shred(sewed, *shreds)
+      execute(sewed, shreds, true)
+    end
+
+    def sew(sewed, *shreds)
+      execute(sewed, shreds, false)
+    end
+
+  end
+
+end

data/lib/shredder/streams.rb

@@ -1,18 +1,23 @@
-module Shredder
+module SHREDDER
+
   class Streams
+    extend Functions 
+
     # this one takes streams
-    def initialize(sew,shreds,limit=0)
-      @sew = sew
+    def initialize(sew, shreds, limit=0)
+      @sew    = sew
       @shreds = shreds
-      @limit = limit
+      @limit  = limit
     end
 
     def shred(limit=@limit)
-      Shredder.shred(@sew,@shreds,limit)
+      Streams.shred(@sew,@shreds,limit)
     end
 
     def sew(limit=@limit)
-      Shredder.sew(@sew,@shreds,limit)
+      Streams.sew(@sew,@shreds,limit)
     end
+
   end
+
 end

data/lib/shredder/version.rb

@@ -0,0 +1,5 @@
+module SHREDDER
+
+  VERSION = '1.0.0'
+
+end

data/shredder.gemspec

@@ -0,0 +1,55 @@
+Gem::Specification.new do |s|
+
+  s.name     = 'shredder'
+  s.version  = '1.0.0'
+
+  s.homepage = 'https://github.com/carlosjhr64/shredder'
+
+  s.author   = 'CarlosJHR64'
+  s.email    = 'carlosjhr64@gmail.com'
+
+  s.date     = '2014-01-11'
+  s.licenses = ['MIT']
+
+  s.description = <<DESCRIPTION
+Shred a file into file fragments, and join fragments back into a restored file.
+
+Disperse file shreds in separate depositories
+so that no one depository has the entire file.
+DESCRIPTION
+
+  s.summary = <<SUMMARY
+Shred a file into file fragments, and join fragments back into a restored file.
+SUMMARY
+
+  s.extra_rdoc_files = ['README.rdoc']
+  s.rdoc_options     = ["--main", "README.rdoc"]
+
+  s.require_paths = ["lib"]
+  s.files = %w(
+History.txt
+README.rdoc
+TODO.txt
+bin/shredder
+features/main.feature
+features/step_definitions/main_steps.rb
+lib/shredder.rb
+lib/shredder/files.rb
+lib/shredder/functions.rb
+lib/shredder/shredder.rb
+lib/shredder/streams.rb
+lib/shredder/version.rb
+shredder.gemspec
+test/test_shredder.rb
+  )
+  s.executables << 'shredder'
+  s.add_runtime_dependency 'help_parser', '~> 1.1', '>= 1.1.0'
+  s.add_development_dependency 'test-unit', '~> 2.5', '>= 2.5.5'
+  s.add_development_dependency 'symmetric_gpg', '~> 2.0', '>= 2.0.1'
+  s.requirements << 'ruby: ruby 2.1.0p0 (2013-12-25 revision 44422) [x86_64-linux]'
+  s.requirements << 'bash in development: GNU bash, version 4.2.25(1)-release (x86_64-pc-linux-gnu)'
+  s.requirements << 'system in development: linux/bash'
+  s.requirements << 'rm in development: rm (GNU coreutils) 8.13'
+  s.requirements << 'diff in development: diff (GNU diffutils) 3.2'
+
+end

data/test/test_shredder.rb

@@ -0,0 +1,140 @@
+# Standard Libraries
+require 'stringio'
+
+# Gems
+require 'test/unit'
+begin
+  require 'symmetric_gpg'
+  GPG = true
+rescue
+  STDERR.puts "Warning: symmetric_gpg not available for testing"
+  GPG = false
+end
+
+# This Gem
+require 'shredder'
+include SHREDDER
+
+module TestFunction
+  extend Functions
+end
+
+class TestShredder < Test::Unit::TestCase
+
+  def test_version
+    assert_equal '1.0.0', VERSION
+    assert_equal '1.0.0', SHREDDER::VERSION
+  end
+
+  def test_functions_even
+    abc  = "abcdefghijklmnopqrstuvwxyz"
+    string = StringIO.new(abc)
+    shred1 = StringIO.new
+    shred2 = StringIO.new
+    TestFunction.shred(string, [shred1, shred2])
+    string.rewind
+    shred1.rewind
+    shred2.rewind
+    l0, l1, l2 = string.length, shred1.length, shred2.length
+    assert_equal(l0, l1 + l2)
+    assert_equal(l1, l2)
+    sewed  = StringIO.new
+    TestFunction.sew(sewed, [shred1, shred2])
+    sewed.rewind
+    assert_equal(sewed.read, abc)
+
+    # Note that the xor starts it's seed with the first letter,
+    # so that 'a' in the abc string remains unchanged.
+    # Anyways, the point of the following is to show that the shreds
+    # are no longer easily recognizable as part of the original string.
+
+    shred1.rewind
+    shred = shred1.read
+    assert_nil(shred=~/[b-z]/)
+
+    shred2.rewind
+    shred = shred2.read
+    assert_nil(shred=~/[b-z]/)
+  end
+
+  def test_functions_odd
+    abc  = "abcdefghijklmnopqrstuvwxyz+"
+    string = StringIO.new(abc)
+    shred1 = StringIO.new
+    shred2 = StringIO.new
+    TestFunction.shred(string, [shred1, shred2])
+    string.rewind
+    shred1.rewind
+    shred2.rewind
+    l0, l1, l2 = string.length, shred1.length, shred2.length
+    assert_equal(l0, l1 + l2)
+    assert_equal(l1, l2+1)
+    sewed  = StringIO.new
+    TestFunction.sew(sewed, [shred1, shred2])
+    sewed.rewind
+    assert_equal(sewed.read, abc)
+  end
+
+  def test_functions_three
+    abc  = "abcdefghijklmnopqrstuvwxyz"
+    string = StringIO.new(abc)
+    shred1 = StringIO.new
+    shred2 = StringIO.new
+    shred3 = StringIO.new
+    TestFunction.shred(string, [shred1, shred2, shred3])
+    string.rewind
+    shred1.rewind
+    shred2.rewind
+    shred3.rewind
+    l0, l1, l2, l3 = string.length, shred1.length, shred2.length, shred3.length
+    assert_equal(l0, l1 + l2 + l3)
+    assert(l1>7)
+    assert(l2>7)
+    assert(l3>7)
+    sewed  = StringIO.new
+    TestFunction.sew(sewed, [shred1, shred2, shred3])
+    sewed.rewind
+    assert_equal(sewed.read, abc)
+  end
+
+  # Most of the code is tested under cucumber.
+  # Just going to test an untested path.
+  # Shredder.new(...).execute is well tested.
+  # Now test Shredder.new.shred and #sew
+  def test_shredder
+    system('rm ./temp.* 2> /dev/null')
+    refute File.exist? './temp.sewed' # just a quick sanity check
+    system('openssl rand -base64 32 > ./temp.txt')
+    shredder = Shredder.new
+    # ...and just for something a bit different, 4 shreds.
+    shredder.shred('./temp.txt', './temp.1', './temp.2', './temp.3', './temp.4')
+    assert File.exist? './temp.1'
+    assert File.exist? './temp.2'
+    assert File.exist? './temp.3'
+    assert File.exist? './temp.4'
+    shredder.sew('./temp.sewed', './temp.1', './temp.2', './temp.3', './temp.4')
+    assert File.exist? './temp.sewed'
+    # The following will show the two files to be equal
+    assert system 'diff ./temp.txt ./temp.sewed 2> /dev/null'
+
+    system('rm ./temp.*') # cleanup after ourselves
+  end
+
+  def test_symmetric_gpg
+    if GPG
+      system('rm ./temp.* 2> /dev/null')
+      string = "A is for Apple."
+      shreds = SymmetricGPG::Shreds.new("Shreddelicious!", string, ['./temp.1','./temp.2'])
+      shreds.shredder = '/usr/local/bin/ruby -I ./lib ./bin/shredder'
+      shreds.shred # Should encrypt and then shred the string into shred.1 and shred.2.
+      assert File.exist? './temp.1'
+      assert File.exist? './temp.2'
+      shreds.plain = nil # no cheat!
+      plain = shreds.sew # should get the shredded string back.
+      assert_equal string, plain
+      # Cleanup after ourselves
+      system('rm ./temp.* 2> /dev/null')
+    end
+  end
+
+end

metadata

@@ -1,73 +1,131 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: shredder
-version: !ruby/object:Gem::Version 
-  hash: 23
-  prerelease: 
-  segments: 
-  - 0
-  - 2
-  - 0
-  version: 0.2.0
+version: !ruby/object:Gem::Version
+  version: 1.0.0
 platform: ruby
-authors: 
-- carlosjhr64@gmail.com
+authors:
+- CarlosJHR64
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-06-21 00:00:00 Z
-dependencies: []
-
+date: 2014-01-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: help_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.5
+- !ruby/object:Gem::Dependency
+  name: symmetric_gpg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.1
 description: |
-  The idea is to disperse file shreds in separate depositories
-  such that no one depository has the entire file.
-  Note: These are not file segments, they're shreds.
+  Shred a file into file fragments, and join fragments back into a restored file.
 
+  Disperse file shreds in separate depositories
+  so that no one depository has the entire file.
 email: carlosjhr64@gmail.com
-executables: 
+executables:
 - shredder
 extensions: []
-
-extra_rdoc_files: []
-
-files: 
-- ./lib/shredder/streams.rb
-- ./lib/shredder/files.rb
-- ./lib/shredder.rb
-- ./README.txt
+extra_rdoc_files:
+- README.rdoc
+files:
+- History.txt
+- README.rdoc
+- TODO.txt
 - bin/shredder
-homepage: https://sites.google.com/site/carlosjhr64/rubygems/shredder
-licenses: []
-
+- features/main.feature
+- features/step_definitions/main_steps.rb
+- lib/shredder.rb
+- lib/shredder/files.rb
+- lib/shredder/functions.rb
+- lib/shredder/shredder.rb
+- lib/shredder/streams.rb
+- lib/shredder/version.rb
+- shredder.gemspec
+- test/test_shredder.rb
+homepage: https://github.com/carlosjhr64/shredder
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
-rdoc_options: []
-
-require_paths: 
+rdoc_options:
+- "--main"
+- README.rdoc
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-requirements: []
-
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- 'ruby: ruby 2.1.0p0 (2013-12-25 revision 44422) [x86_64-linux]'
+- 'bash in development: GNU bash, version 4.2.25(1)-release (x86_64-pc-linux-gnu)'
+- 'system in development: linux/bash'
+- 'rm in development: rm (GNU coreutils) 8.13'
+- 'diff in development: diff (GNU diffutils) 3.2'
 rubyforge_project: 
-rubygems_version: 1.8.4
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
-summary: Shred a file into file fragments, and join fragments back into a restored file.
+specification_version: 4
+summary: Shred a file into file fragments, and join fragments back into a restored
+  file.
 test_files: []
-

data/README.txt

@@ -1,28 +0,0 @@
-### SYNOPSIS ###
-
-require 'shredder'
-
-# Shreds text.txt into test.f.1, test.f.2, test.f.3
-Shredder::Files.new('README.txt', ['test.f.1','test.f.2','test.f.3'] ).shred
-
-# Sews test.f.1, test.f.2, test.f.3 into restored.f.txt
-Shredder::Files.new('restored.f.txt', ['test.f.1','test.f.2','test.f.3'] ).sew
-
-# or #
-
-# shred streams #
-reader = File.open('README.txt','r')
-writers = []; ['test.s.1','test.s.2','test.s.3'].each{|writer| writers.push(File.open(writer,'wb'))}
-Shredder::Streams.new(reader,writers).shred
-reader.close
-writers.each{|writer| writer.close}
-
-# sew streams
-writer = File.open('restored.s.txt','wb')
-readers = []; ['test.s.1','test.s.2','test.s.3'].each{|writer| readers.push(File.open(writer,'r'))}
-Shredder::Streams.new(writer,readers).sew
-writer.close
-readers.each{|reader| reader.close}
-
-# Also available, Shredder.shred( writer, readers) and Shredder.sew( reader, writers )
-# and a command line utility, shredder (run shredder --help for more info).