shredder 1.0.0 → 2.0.200126

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 86de11dca31147b96703885615c3727a7256bda2
-  data.tar.gz: 10147305bd2892e76a56b5ad8378f52470c4be5d
+SHA256:
+  metadata.gz: 498eeb86b0aea1ba926ec9c2dd168d41ef4467dd64ff79e7e712f3141aec4e02
+  data.tar.gz: 654802da4b46624cc48f87ca2d6aa949ba451fade334c6ce77a5c7836465938d
 SHA512:
-  metadata.gz: 5f19a35eb7ba38592f328f0d87e93401ae528b470c6046d81ace2d4b0dfbaf1db2e8a07df8d41a2a2e86091d7969d52e51889d78988037cc53c71b3d7aeb83a4
-  data.tar.gz: cfb6ccd2fcecd29df7a02c24caba969a06e7025ea8b82c2af782d1aa5a2c994c1eb2dff806e0e31169c426ae904ef07af6bb90c1f9c015c17e759fbd010f7ac0
+  metadata.gz: 52830fd82dd9711003bd78e039df4467e66b95b013ca622c28103e65265dbe8b02841f886008db00b66508e2e34a47eb8f586c398b11fecf41e2ed5bcc6274c2
+  data.tar.gz: 766b712345d5efa6783a730d4f9afb4a00fe48e40a7f805a65252c7075edf1bad5f6cb750ab388f842e4accd2e58bb26612d6ed1b6d43eb85f57dbcdb9f5d929

data/README.md

@@ -0,0 +1,113 @@
+# shredder
+
+* [VERSION 2.0.200126](https://github.com/carlosjhr64/shredder/releases)
+* [github](https://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.
+
+## HELP:
+
+    $ Usage:
+    $   shredder shred [:options+] <shreds=FILENAME>+
+    $   shredder sew [:options+] <shreds=FILENAME>+
+    $ Options:
+    $   --n=INTEGER 	Number of shreds
+    $   --passphrase	Relay passphrase from stding to stdout
+    $ Types:
+    $   FILENAME   /^[[:print:]]+$/
+    $   INTEGER    /^[2-9]d*$/
+    $ # Examples:
+    $ #   shredder shred file.1 file.2 < file.txt
+    $ #   shredder shred --n=2 file < file.txt
+    $ #   shredder sew file.1 file.2 > file.txt
+    $ #   shredder shred --n=2 file > file.txt
+
+## SYNOPSIS
+
+### Library:
+
+    require 'shredder'
+
+#### Shredder::Streams
+
+    require 'stringio'
+
+    sewn = StringIO.new("This is a test String: 1, 2, 3.")
+    sewn.string.length #=> 31
+    shreds = [StringIO.new, StringIO.new]
+
+    shredder = Shredder::Streams.new(sewn, shreds)
+    shredder.shred #=> 31
+
+    shreds[0].string
+    #=> "T\u0001S\u001AAT\u0016T'\e\t\u001A\u001D\u0012\f\u001D"
+    shreds[0].string.length #=> 16
+
+    shreds[1].string
+    #=> "<\u001AISA\u0011\as\u0006\a]\u0011\f\u001E\u0013"
+    shreds[1].string.length #=> 15
+
+    restored = StringIO.new
+    shreds.each{|_|_.rewind}
+
+    shredder = Shredder::Streams.new(restored, shreds)
+    shredder.sew #=> 31
+
+    restored.string #=> "This is a test String: 1, 2, 3."
+
+#### Shredder::Files
+
+    sewn = './tmp/sewn.txt'
+    shreds = './tmp/shreds'
+    restored  = './tmp/restored.txt'
+
+    File.read(sewn).chomp #=> "This is a test file: 1, 2, 3."
+    File.size(sewn) #=> 30
+
+    shredder = Shredder::Files.new(sewn, shreds, 3)
+    shredder.shreds
+    #=> ["./tmp/shreds.1", "./tmp/shreds.2", "./tmp/shreds.3"]
+    shredder.shred #=> 30
+
+    File.read(shreds+'.1') #=> "T\u001A\u001AA\u0016F\t\u0011\u0012\u0013"
+    File.read(shreds+'.2') #=> "<SST\a\u000F_\u001D\u001E\u001D"
+    File.read(shreds+'.3') #=> "\u0001IA\u0011T\u0005\u001A\f\f$"
+    File.size(shreds+'.3') #=> 10
+
+    shredder = Shredder::Files.new(restored, shreds, 3)
+    shredder.sewn #=> "./tmp/restored.txt"
+    shredder.sew #=> 30
+    File.read(restored).chomp #=> "This is a test file: 1, 2, 3."
+
+## INSTALL:
+
+    $ gem install shredder
+
+## LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2020 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/bin/shredder

@@ -1,43 +1,55 @@
 #!/usr/bin/env ruby
-
-# Gems:
 require 'help_parser'
 
-# This Gem:
-require 'shredder'
-include SHREDDER
-
-NAME = File.basename $0 # Program Name
-HELP = <<HELP
-Usage: #{NAME} [options] [file] shred1 shred2...
+OPTIONS = HelpParser['2.0.200126', <<HELP]
+Usage:
+  shredder shred [:options+] <shreds=FILENAME>+
+  shredder sew [:options+] <shreds=FILENAME>+
 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.
-
-  -h --help      Puts this help and exits.
-  -v --version   Puts version and exits.
-
-  -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}
+  --n=INTEGER \tNumber of shreds
+  --passphrase\tRelay passphrase from stding to stdout
+Types:
+  FILENAME   /^[[:print:]]+$/
+  INTEGER    /^[2-9]\d*$/
+# Examples:
+#   shredder shred file.1 file.2 < file.txt
+#   shredder shred --n=2 file < file.txt
+#   shredder sew file.1 file.2 > file.txt
+#   shredder shred --n=2 file > file.txt
 HELP
+HelpParser.int?(:n)
 
-begin
-  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
+shreds = OPTIONS.shreds
+count = shreds.length
+if n = OPTIONS.n?
+  if count == 1
+    count = n
+    shreds = shreds.first
+  elsif count != n
+    $stderr.puts "shred count(#{count}) not equal to n(#{n})."
+    exit 64
+  end
+end
+unless count > 1
+  $stderr.puts "shred count must be at least 2"
   exit 64
 end
+
+require 'shredder/shredder'
+require 'shredder/streams'
+require 'shredder/stdio'
+
+shredder = Shredder::StdIO.new(shreds, count)
+case OPTIONS[1]
+when 'shred'
+  shredder.shred
+when 'sew'
+  begin
+    shredder.sew
+  rescue Errno::ENOENT
+    # Common expected type of error,
+    # user tries to sew non-existing shreds.
+    $stderr.puts $!.message
+    exit 65
+  end
+end

data/lib/shredder.rb

@@ -1,8 +1,9 @@
-require 'shredder/version'
-require 'shredder/functions'
-require 'shredder/files'
-require 'shredder/streams'
+module Shredder
+  VERSION = '2.0.200126'
+end
 require 'shredder/shredder'
-
+require 'shredder/streams'
+require 'shredder/stdio'
+require 'shredder/files'
 # Requires:
 #`ruby`

data/lib/shredder/files.rb

@@ -1,51 +1,37 @@
-module SHREDDER
-
+module Shredder
   class Files
-    extend Functions
-
-     # this one takes filenames
-    def initialize(sew, shreds, limit=0)
-      @sew    = sew
-      @shreds = shreds
-      @limit  = limit
+    include Shredder
+    # this one takes filenames
+    def initialize(sewn, shreds=sewn, m=2, n: m)
+      @sewn   = sewn
+      @shreds = shred_files(shreds, n)
+      raise "Need at least 2 shreds" unless @shreds.length > 1
     end
 
-    def shred(limit=@limit)
-      reader  = File.open(@sew, 'r')
-      writers = []
-      @shreds.each{|shred| writers.push(File.open(shred, 'wb'))}
-
-      count = nil
+    def shred(limit=0)
+      reader = writers = count = nil
       begin
-        count = Files.shred(reader, writers, limit)
-      rescue Exception
-        raise $!
+        reader  = File.open(@sewn, 'r')
+        writers = @shreds.map{|shred| File.open(shred, 'wb')}
+        count   = Streams.new(reader, writers).shred(limit: limit)
       ensure
-        writers.each{|writer| writer.close}
-        reader.close
-       end
-
+        writers.each{|writer| writer.close}  if writers
+        reader.close                         if reader
+      end
       return count
     end
 
-    def sew(limit=@limit)
-      writer  = File.open(@sew, 'wb')
-      readers = []
-      @shreds.each{|shred| readers.push(File.open(shred, 'r'))}
-
-      count = nil
+    def sew(limit=0)
+      writer = readers = count = nil
       begin
-        count = Files.sew(writer, readers, limit)
-      rescue Exception
-        raise $!
+        writer  = File.open(@sewn, 'wb')
+        readers = @shreds.map{|shred| File.open(shred, 'r')}
+        count   = Streams.new(writer, readers).sew(limit: limit)
       ensure
-        writer.close
-        readers.each{|reader| reader.close}
+        writer.close                          if writer
+        readers.each{|reader| reader.close}   if readers
       end
-
       return count
     end
-
   end
-
 end

data/lib/shredder/shredder.rb

@@ -1,46 +1,40 @@
-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
+module Shredder
+  attr_accessor :sewn, :shreds
+
+  # note that these are streams
+  def shred(sewn=(@sewn or $stdin), shreds=@shreds,
+            writers: shreds, reader: sewn, limit: 0)
+    shreds,xor,count = writers.length,0,0
+    while byte = reader.getbyte do
+      writers[count%shreds].putc(xor^(xor=byte))
+      count += 1 # not that 0 is skipped
+      break if count == limit
     end
+    return count
+  end
 
-    def shred(sewed, *shreds)
-      execute(sewed, shreds, true)
+  # note that these are streams
+  def sew(shreds=@shreds, sewn=(@sewn or $stdout),
+          readers: shreds, writer: sewn, limit: 0)
+    shreds,xor,count = readers.length,0,0
+    while byte = readers[count%shreds].getbyte do
+      writer.putc(xor=(byte^xor))
+      count += 1 # note that 0 is skipped
+      break if count == limit
     end
+    return count
+  end
 
-    def sew(sewed, *shreds)
-      execute(sewed, shreds, false)
+  def shred_files(b, m=2, basename: b, n: m)
+    case basename
+    when Array
+      basename
+    when String
+      (1..n).map{|i| "#{basename}.#{i}"}
+    when Integer
+      (1..basename).map{|i| "#{@sewn or 'shred'}.#{i}"}
+    else
+      raise "Expected basename Array|String|Integer"
     end
-
   end
-
 end

data/lib/shredder/stdio.rb

@@ -0,0 +1,31 @@
+module Shredder
+  class StdIO
+    include Shredder
+    # this one takes shred filenames and uses $stdin or $stdout appropriately.
+    def initialize(*args)
+      @shreds = shred_files(*args)
+    end
+
+    def shred(limit=0)
+      writers = count = nil
+      begin
+        writers = @shreds.map{|shred| File.open(shred, 'wb')}
+        count   = Streams.new($stdin, writers).shred(limit: limit)
+      ensure
+        writers.each{|writer| writer.close}  if writers
+      end
+      return count
+    end
+
+    def sew(limit=0)
+      readers = count = nil
+      begin
+        readers = @shreds.map{|shred| File.open(shred, 'r')}
+        count   = Streams.new($stdout, readers).sew(limit: limit)
+      ensure
+        readers.each{|reader| reader.close}  if readers
+      end
+      return count
+    end
+  end
+end

data/lib/shredder/streams.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shredder
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.200126
 platform: ruby
 authors:
-- CarlosJHR64
+- carlosjhr64
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-11 00:00:00.000000000 Z
+date: 2020-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: help_parser
@@ -16,94 +16,43 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '6.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 6.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '6.5'
     - - ">="
       - !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: |
-  Shred a file into file fragments, and join fragments back into a restored file.
+        version: 6.5.0
+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.
+  '
 email: carlosjhr64@gmail.com
 executables:
 - shredder
 extensions: []
-extra_rdoc_files:
-- README.rdoc
+extra_rdoc_files: []
 files:
-- History.txt
-- README.rdoc
-- TODO.txt
+- README.md
 - 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/stdio.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:
-- "--main"
-- README.rdoc
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -117,13 +66,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !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: 2.2.0
+- 'ruby: ruby 2.7.0p0 (2019-12-25 revision 647ee6f091) [x86_64-linux]'
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Shred a file into file fragments, and join fragments back into a restored

data/README.rdoc

@@ -1,58 +0,0 @@
-= 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

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

data/features/main.feature

@@ -1,72 +0,0 @@
-@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

@@ -1,77 +0,0 @@
-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/functions.rb

@@ -1,36 +0,0 @@
-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/version.rb

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

data/shredder.gemspec

@@ -1,55 +0,0 @@
-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

@@ -1,140 +0,0 @@
-# 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