shredder 0.1.1 → 3.0.210928

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 79cdefe01e4a370cbeabff63ec4e641945d62b239aef721050257e0a9bcf0119
+  data.tar.gz: d5290e49de44088fbb83a3615cea8ee7af5781b162fe3c49d202bfbe8e9a1779
+SHA512:
+  metadata.gz: 28b6169312efdfaed3e1cc5365b866d177d09cbea1085d12eea12e63dc61f05a4561a8ea986e8f3ddd6e8e820656340d01f4f5f1e325a59b63f47bd3cb33d7fe
+  data.tar.gz: ad2d383ac37cd98d80676026e9d10f8c3092e3bb5f504404938809733a1e31e9e7ab4328afd596b63f83a35b04d48212e90f327446ef047deb04dce1187645f6

data/README.md

@@ -0,0 +1,112 @@
+# Shredder
+
+* [VERSION 3.0.210928](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.
+
+## INSTALL:
+```console
+$ gem install shredder
+```
+## HELP:
+```console
+$ shredder --help
+Usage:
+  shredder shred [:options+] <shreds=FILENAME>+
+  shredder sew [:options+] <shreds=FILENAME>+
+Options:
+  --n=INTEGER 	 Number of shreds
+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
+```ruby
+require 'shredder'
+```
+#### Shredder::Streams
+```ruby
+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
+```ruby
+sewn = './test/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."
+```
+## LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2021 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,73 +1,51 @@
 #!/usr/bin/env ruby
+require 'help_parser'
 require 'shredder'
-raise "Need Shredder version ~> 0.1" if Shredder::VERSION < '0.1'
 
-# Command line utility
-class ShredderCommandLine
-  def self.version
-    puts Shredder::VERSION
-    exit(0)
-  end
-
-  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
-EOT
-    print "VERSION: "
-    ShredderCommandLine.version
-  end
-
-  def self.parse_argv
-    options = ''
-    while ARGV[0]=~/^-/ do
-      options += ARGV.shift
-    end
-    ShredderCommandLine.version if options =~ /-v\b/ || options =~ /--version\b/ # need to allow verbose below.
-    ShredderCommandLine.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
+OPTIONS = HelpParser[Shredder::VERSION, <<HELP]
+Usage:
+  shredder shred [:options+] <shreds=FILENAME>+
+  shredder sew [:options+] <shreds=FILENAME>+
+Options:
+  --n=INTEGER \t Number of shreds
+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)
 
-  def initialize
-    options = ShredderCommandLine.parse_argv
-    @shredding = (options=~/--shred/)? 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
-
-  def execute
-    shredder = (@sew.class == String)? Shredder::Files.new(@sew,@shreds): Shredder::Streams.new(@sew,@shreds)
-    begin
-      (@shredding)? shredder.shred : shredder.sew
-    rescue StandardError
-      $stderr.puts $!
-    ensure
-      @shreds.each{|filehandle| filehandle.close}	if !(@sew.class == String)
-    end
+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
 
-begin
-  ShredderCommandLine.new.execute
-rescue StandardError
-  $stderr.puts $!
-  $stderr.puts $!.backtrace if $verbose
+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/files.rb

@@ -1,45 +1,36 @@
 module Shredder
   class Files
-     # 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 = Shredder.shred( reader, writers, limit )
-      rescue Exception
-        raise $!
+        reader  = File.open(@sewn, 'r')
+        writers = @shreds.map{File.open _1, 'wb'}
+        count   = Streams.new(reader, writers).shred(limit: limit)
       ensure
-        writers.each{|writer| writer.close}
-        reader.close
-       end
-
+        writers.each{_1.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 = Shredder.sew( writer, readers, limit )
-      rescue Exception
-        raise $!
+        writer  = File.open(@sewn, 'wb')
+        readers = @shreds.map{File.open(_1, 'r')}
+        count   = Streams.new(writer, readers).sew(limit: limit)
       ensure
-        writer.close
-        readers.each{|reader| reader.close}
+        writer.close            if writer
+        readers.each{_1.close}  if readers
       end
-
       return count
     end
   end

data/lib/shredder/shredder.rb

@@ -0,0 +1,40 @@
+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, xor: 0)
+    shreds,count = writers.length,0
+    while byte = reader.getbyte do
+      writers[count%shreds].putc(xor^(xor=byte))
+      count += 1 # note that 0 is skipped
+      break if count == limit
+    end
+    return count
+  end
+
+  # note that these are streams
+  def sew(shreds=@shreds, sewn=(@sewn or $stdout),
+          readers: shreds, writer: sewn, limit: 0, xor: 0)
+    shreds,count = readers.length,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 shred_files(b=nil, 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{File.open _1, 'wb'}
+        count   = Streams.new($stdin, writers).shred(limit: limit)
+      ensure
+        writers.each{_1.close}  if writers
+      end
+      return count
+    end
+
+    def sew(limit=0)
+      readers = count = nil
+      begin
+        readers = @shreds.map{File.open _1, 'r'}
+        count   = Streams.new($stdout, readers).sew(limit: limit)
+      ensure
+        readers.each{_1.close}  if readers
+      end
+      return count
+    end
+  end
+end

data/lib/shredder/streams.rb

@@ -1,18 +1,10 @@
 module Shredder
   class Streams
+    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)
-      Shredder.shred(@sew,@shreds,limit)
-    end
-
-    def sew(limit=@limit)
-      Shredder.sew(@sew,@shreds,limit)
     end
   end
 end

data/lib/shredder.rb

@@ -1,35 +1,9 @@
 module Shredder
-  VERSION = '0.1.1'
-
-  # 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'
+  VERSION = '3.0.210928'
+  require 'shredder/shredder'
+  autoload :Streams, 'shredder/streams'
+  autoload :StdIO,   'shredder/stdio'
+  autoload :Files,   'shredder/files'
 end
+# Requires:
+#`ruby`

metadata

@@ -1,73 +1,75 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: shredder
-version: !ruby/object:Gem::Version 
-  hash: 25
-  prerelease: 
-  segments: 
-  - 0
-  - 1
-  - 1
-  version: 0.1.1
+version: !ruby/object:Gem::Version
+  version: 3.0.210928
 platform: ruby
-authors: 
-- carlosjhr64@gmail.com
-autorequire: 
+authors:
+- CarlosJHR64
+autorequire:
 bindir: bin
 cert_chain: []
+date: 2021-09-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: help_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.210917
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.210917
+description: 'Shred a file into file fragments, and join fragments back into a restored
+  file.
 
-date: 2011-06-21 00:00:00 Z
-dependencies: []
-
-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.
-
+  '
 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
+files:
+- README.md
 - bin/shredder
-homepage: https://sites.google.com/site/carlosjhr64/rubygems/shredder
-licenses: []
-
-post_install_message: 
+- lib/shredder.rb
+- lib/shredder/files.rb
+- lib/shredder/shredder.rb
+- lib/shredder/stdio.rb
+- lib/shredder/streams.rb
+homepage: https://github.com/carlosjhr64/shredder
+licenses:
+- MIT
+metadata: {}
+post_install_message:
 rdoc_options: []
-
-require_paths: 
+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: []
-
-rubyforge_project: 
-rubygems_version: 1.8.4
-signing_key: 
-specification_version: 3
-summary: Shred a file into file fragments, and join fragments back into a restored file.
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- 'ruby: ruby 3.0.2p107 (2021-07-07 revision 0db68f0233) [x86_64-linux]'
+rubygems_version: 3.2.22
+signing_key:
+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('test.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('test.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).