file-replicator 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2821c812b1a84db10f90aff6be2cef29ee814f50
+  data.tar.gz: 4a68856122d98a88117626ad646aa1cd1aba601a
+SHA512:
+  metadata.gz: f5b3071ba86f0a4673680899a5dcbad7153b311928aa657603797a261c7580b71065b69e93b545a105e8a1547b6693cb022ce06b1932ee5720f519ffd76e6022
+  data.tar.gz: 91320af8216bade935f9fce93ad2cb5e49ae35520b700e4201ca1379cec1f0e1faf66fe3871f7ab960dd602bbd5e544a428d3c375862d90f3402478567a9ae6c

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at vad.viktor@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in file-split-join-binary.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Viktor (Icon) VAD
+
+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/README.md

@@ -0,0 +1,139 @@
+# File replicator, a split-join command line tool
+
+This Gem provides you with two command line tools, one to split up files and one to join them back togather again.
+Splitting operation is binary only, making it mostly suitable for files like huge images, videos, archive formats, etc. Since it is binary it should not have any problems splitting and then joining text files, just mind that it can break reading part files as they may loose line ending info until they are joined.
+
+## Features
+
+- progress bar per file
+- checksum algorithms: md5, sha1, sha224, sha256, sha318, sha512
+
+
+## Installation
+
+    gem install file-replicator
+
+If you are using [rbenv](https://github.com/rbenv/rbenv), don't forget to `rehash` to pick up new executables:
+
+    rbenv rehash
+
+## Usage
+
+### Splitting files
+
+To split files use the `rsplit` command. When it is used without arguments it will print it's parameter list:
+    
+```
+$ rsplit
+usage: rsplit [options]
+    -f, --files       Files to split, Ruby's Dir.glob style
+    -o, --output-dir  Destination directory, (default: current directory)
+    -p, --pattern     Output file pattern, details in the --readme (default: {orf}.{onu})
+    (...truncated...)
+```
+
+There is a built in, very valuable `manual` with the `--readme` parameter:
+
+    $ rsplit --readme
+
+#### Examples
+
+* For the examples below take the following structure:
+
+```
+$ tree -h /mnt
+/mnt/
+├── [   0]  rugby
+│   └── [1.1G]  match.mkv
+├── [ 43M]  tv1.mkv
+├── [ 94M]  tv2.mkv
+└── [103M]  tv3.mkv
+```
+
+* Split one file into 3 parts and store them in `/opt`:
+
+```
+$ rsplit -f /mnt/rugby/match.mkv -o /opt -e 3
+```
+    
+* To split more files you can use [Ruby's Dir.glob patterns](https://ruby-doc.org/core-2.3.0/Dir.html#method-c-glob):
+```    
+$ rsplit -f "/mnt/tv*.mkv"
+```
+    
+will match tv1.mvk, tv2.mkv and tv3.mkv too.    
+
+**NOTE**: to avoid shells' path pattern translation you have to put the pattern in between quotes.
+
+* Whenever you wish to split many files with mixed sizes, where there are a few files just too small you wish not to process you can use the `--min-size` option.
+
+So let's exclude any file that is just smaller than 50 megabytes:  
+
+```
+$ rsplit rsplit -f "/mnt/tv*.mkv" -m 50m
+```
+
+will match tv2.mkv and tv3.mkv and NOT tv1.mkv which is only 43M small.
+
+* Apart from controlling the destination folder you may not want to rename the source file(s) just to get the expected output chunk files. This is where the output file name `--pattern` option come in play.
+
+Use these building blocks to extract, reuse and add parts to construct output filenames.
+The patterns are case insensitive and the surrounding curly braces are part of them (see example).
+
+    {ord} - Original, absolute directory
+    {orf} - Original filename, with extension
+    {ore} - File's (last) extension with the lead dot: .jpg
+    {orb} - File's name without it's extension
+    {num} - Incremental numbers starting at 1: [1, 2, 3, ...]
+    {onu} - Incremental numbers starting at 1 and padded with zeros: [01, 02, ... 10, 11]
+    {gcn} - Incremental numbers starting at 1: [1, 2, 3, ...], used in multi file scenario
+
+  E.g. you want to rename every file to a fixed name with a zero prefixed number prefix:
+   
+```
+  $ rsplit -f "/mnt/**/*.mkv" -p {onu}_tv-match-{gcn}.mkv
+```
+
+will name the split files like:
+
+```
+1_tv-match-1.mkv
+2_tv-match-1.mkv
+1_tv-match-2.mkv
+2_tv-match-2.mkv
+```
+
+**NOTE**:
+  - You MUST use `{gcn}` in your file name as it will count the main files, so you will still be able to distinguish files.
+  - Files, when gathered according the Dir.glob pattern will be then sorted by the default sort algorithm for Ruby Arrays. That is going to affect how the files are going to be numbered by `{gcn}`.
+
+### Joinging files
+
+Joining file chunks is a more basic operation with less options.
+Basically the supplied `rjoin` command is really just a little bit boosted linux `cat`.
+
+YOu are able to combine a list of files in alphabetical order (as far as Ruby's Array#sort goes) by just defining the first and last file, and rjoin will get the file in between:
+
+    $ rjoin -f file.bin.001 -l file.bin.125 -o file.bin
+    
+will join the 125 chunks into file.bin. Work pretty good because the numbering is zero prefixed and alphabetical sorting will do it's job as you expect.
+
+## Todo list
+
+- [ ] Write a nice `--readme` for `rjoin`
+- [ ] Do checksum verification upon joining
+- [ ] Figure out more tests
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/vadviktor/whatever. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](CODE_OF_CONDUCT.md) code of conduct. 
+
+1. Fork it (https://github.com/vadviktor/file-replicator/fork)
+2. Create your feature branch (git checkout -b my-new-feature)
+3. Commit your changes (git commit -am 'Add some feature')
+4. Push to the branch (git push origin my-new-feature)
+5. Create a new Pull Request
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "file/split/join/binary"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/rjoin

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/file_replicator/joiner'
+
+FileReplicator::Joiner.new.join

data/exe/rsplit

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/file_replicator/splitter'
+
+FileReplicator::Splitter.new.split

data/file-split-join-binary.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'file_replicator/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'file-replicator'
+  spec.version       = FileReplicator::VERSION
+  spec.authors       = ['Viktor (Icon) VAD']
+  spec.email         = ['vad.viktor@gmail.com']
+
+  spec.summary       = %q{Split and join files in binary mode}
+  spec.description   = %q{Command line utility that can split files into chunks, join them together. All is done in binary mode making it encoding independent.}
+  spec.homepage      = 'https://github.com/vadviktor/file-replicator'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'slop', '4.4.1'
+  spec.add_dependency 'pastel', '0.6.1'
+  spec.add_dependency 'ruby-progressbar', '1.8.1'
+
+  spec.add_development_dependency 'bundler', '1.13.6'
+  spec.add_development_dependency 'rake', '11.3.0'
+  spec.add_development_dependency 'minitest', '5.9.1'
+  spec.add_development_dependency 'minitest-reporters', '1.1.12'
+end

data/lib/file_replicator/abstract_cmd_parse.rb

@@ -0,0 +1,52 @@
+require 'pastel'
+require 'slop'
+
+require_relative 'checksum'
+require_relative 'exceptions'
+require_relative 'version'
+
+module FileReplicator
+  class AbstractCmdParse
+
+    def initialize
+      @colour = Pastel.new
+    end
+
+    def get_options
+      options = parse_argv
+
+      # display parameter list to let user know how to use them
+      if ARGV.empty?
+        puts options
+        exit
+      end
+
+      validate options
+
+      options
+    rescue MissingArgumentException,
+        ArgumentError,
+        Slop::MissingArgument,
+        Slop::UnknownOption => e
+      puts @colour.bright_red e.message
+      exit 1
+    end
+
+    def header(txt)
+      @colour.yellow.bold.underline txt
+    end
+
+    def highlight(txt)
+      @colour.green.bold txt
+    end
+
+    def parse_argv
+      raise 'Implementation missing'
+    end
+
+    def validate(options)
+      raise 'Implementation missing'
+    end
+
+  end
+end

data/lib/file_replicator/checksum.rb

@@ -0,0 +1,49 @@
+require 'digest'
+
+module FileReplicator
+  class Checksum
+
+    SUPPORTED = [:md5, :sha1, :sha224, :sha256, :sha384, :sha512]
+
+    def initialize(alg)
+      @alg          = alg
+      @file_digest  = Digest.const_get(alg.upcase).new
+      @chunk_digest = Digest.const_get(alg.upcase).new
+    end
+
+    def add_chunk(data)
+      @chunk_digest << data
+      @file_digest << data
+    end
+
+    def start_new_file(file_path)
+      @file_path = file_path
+      @file_digest.reset
+    end
+
+    def start_new_chunk(chunk_file_name)
+      @chunk_file_name = File.basename(chunk_file_name)
+      @chunk_digest.reset
+    end
+
+    def append_chunk_checksum
+      append_to_checksum_file @chunk_digest.hexdigest, @chunk_file_name
+    end
+
+    def append_file_checksum
+      append_to_checksum_file @file_digest.hexdigest, @file_path
+    end
+
+    protected
+
+    def append_to_checksum_file(hexdigest, checksummed_file_path)
+      raise 'No checksum file path is defined' if @file_path.nil?
+
+      chk_filename = "#{@file_path}.#{@alg.downcase}"
+      File.open chk_filename, 'a' do |f|
+        f.write "#{hexdigest}  #{File.basename(checksummed_file_path)}\n"
+      end
+    end
+
+  end
+end

data/lib/file_replicator/exceptions.rb

@@ -0,0 +1,7 @@
+class MissingArgumentException < StandardError
+
+end
+
+class ConflictingArgumentsExceptions < StandardError
+
+end

data/lib/file_replicator/joiner.rb

@@ -0,0 +1,56 @@
+require 'pastel'
+require 'ruby-progressbar'
+
+require_relative 'joiner_cmd_parse'
+require_relative 'replicator_helper'
+
+module FileReplicator
+  class Joiner
+    include ReplicatorHelper
+
+    def initialize
+      @options = JoinerCmdParse.new.get_options
+      @colour  = Pastel.new enabled: !@options[:no_colour]
+    end
+
+    def join
+      files = Dir.glob(
+          File.join(
+              File.dirname(@options[:first]),
+              '*'
+          )
+      ).sort
+
+      prepare @options[:output_path]
+      output_file = File.open @options[:output_path], 'ab'
+
+      first_index = files.index File.expand_path(@options[:first])
+      last_index  = files.index File.expand_path(@options[:last])
+
+      if progress?
+        file_pb = ProgressBar.create(
+            total: (first_index..last_index).size,
+            title: colour.bright_blue("#{File.basename output_file}")
+        )
+      end
+      files[first_index..last_index].each do |file|
+        File.open file, 'rb' do |f|
+          while (data = f.read(READ_BUFFER))
+            output_file.write data
+          end
+        end
+        file_pb.increment if progress?
+      end
+
+      file_pb.finish if progress?
+    rescue StandardError => e
+      puts @colour.bright_red e.message unless quiet?
+      file_pb.stop if progress?
+
+      exit 1
+    ensure
+      output_file.close unless output_file.nil?
+    end
+
+  end
+end

data/lib/file_replicator/joiner_cmd_parse.rb

@@ -0,0 +1,84 @@
+require_relative 'abstract_cmd_parse'
+
+module FileReplicator
+  class JoinerCmdParse < AbstractCmdParse
+
+    protected
+
+    # Parse ARGV
+    # @return Slop options
+    def parse_argv
+      Slop.parse do |o|
+        o.string '-f', '--first', 'First file of the list to combine'
+        o.string '-l', '--last', 'Last file of the list to combine'
+        o.string '-o', '--output-path', 'Destination file path'
+        o.bool '--no-progress', 'Disable progressbar'
+        o.bool '--no-colour', 'Disable colours'
+        o.bool '--quiet', 'Suppress output'
+
+        o.on('--readme', 'Detailed description of some of the parameters and exit') {
+          puts readme
+          exit
+        }
+
+        o.on('--version', 'Display version information and exit') {
+          puts VERSION
+          exit
+        }
+
+        o.on('-h', '--help', 'Display this message') {
+          puts o
+          exit
+        }
+      end
+    end
+
+    def validate(options)
+      validate_first_file options
+      validate_last_file options
+    end
+
+    def validate_first_file(options)
+      unless options.first?
+        msg = 'Missing first input file (-f)'
+        raise MissingArgumentException.new msg
+      end
+
+      unless File.exist? options[:first]
+        msg = "#{options[:first]} does not exist (-f)"
+        raise ArgumentError.new msg
+      end
+    end
+
+    def validate_last_file(options)
+      unless options.last?
+        msg = 'Missing last input file (-l)'
+        raise MissingArgumentException.new msg
+      end
+
+      unless File.exist? options[:last]
+        msg = "#{options[:last]} does not exist (-l)"
+        raise ArgumentError.new msg
+      end
+    end
+
+    # Validates the existence of a directory
+    # @param [Slop] options
+    # @raise ArgumentError
+    def validate_directory(options)
+      unless options.output_path?
+        msg = 'Missing output path (-o)'
+        raise MissingArgumentException.new msg
+      end
+    end
+
+    def readme
+      <<-TXT
+README
+      TXT
+    end
+
+  end
+end
+
+

data/lib/file_replicator/replicator_helper.rb

@@ -0,0 +1,29 @@
+require 'fileutils'
+
+module FileReplicator
+  module ReplicatorHelper
+    READ_BUFFER = 256 * 1024
+
+    attr_reader :options, :colour, :checksum
+
+    protected
+
+    def prepare(file_path)
+      FileUtils.mkdir_p File.dirname(file_path)
+      FileUtils.rm_f file_path
+      FileUtils.touch file_path
+    end
+
+    def quiet?
+      options.quiet?
+    end
+
+    def progress?
+      !options.no_progress? && !quiet?
+    end
+
+    def chksum?
+      !checksum.nil? && !quiet?
+    end
+  end
+end

data/lib/file_replicator/splitter.rb

@@ -0,0 +1,152 @@
+require 'pastel'
+require 'ruby-progressbar'
+
+require_relative 'checksum'
+require_relative 'replicator_helper'
+require_relative 'splitter_cmd_parse'
+
+module FileReplicator
+  class Splitter
+    include ReplicatorHelper
+
+    def initialize
+      @options = SplitterCmdParse.new.get_options
+      @colour  = Pastel.new enabled: !@options[:no_colour]
+
+      if (alg = @options.to_h.fetch(:checksum, false))
+        @checksum = Checksum.new alg
+      end
+    end
+
+    def split
+      file_no = 0
+      files   = Dir.glob(File.expand_path(options[:files])).sort
+      files.each do |file_name|
+        file_no       += 1
+        file_abs_path = File.expand_path(file_name)
+        file_size     = File.size(file_abs_path)
+
+        next if options.min_size? and file_size < size_in_bytes(options[:min_size])
+
+        if options.size?
+          split_size         = size_in_bytes options[:size]
+          number_of_elements = (file_size.to_f / split_size).ceil
+        elsif options.elements?
+          split_size         = (file_size.to_f / options[:elements]).ceil
+          number_of_elements = options[:elements]
+        end
+
+        if progress?
+          file_pb = ProgressBar.create(
+              total: number_of_elements,
+              title: colour.bright_blue("#{File.basename file_name}")
+          )
+        end
+
+        @checksum.start_new_file File.join(options[:output_dir],
+                                           File.basename(file_name)) if chksum?
+
+        File.open file_abs_path, 'rb' do |f|
+          file_split_no = 0
+
+          until f.eof? or f.closed?
+            file_split_no    += 1
+            output_file_path = File.join(
+                options[:output_dir],
+                self.class.pattern_to_path(
+                    options[:pattern],
+                    file_path:    file_abs_path,
+                    file_number:  file_no,
+                    chunk_number: file_split_no,
+                    max_elements: number_of_elements
+                ))
+
+            prepare output_file_path
+
+            bytes_written = 0
+            begin
+              # write to chunk file
+              @checksum.start_new_chunk output_file_path if chksum?
+              split_file = File.open output_file_path, 'ab'
+              while bytes_written <= split_size and (data = f.read(READ_BUFFER))
+                split_file.write data
+                bytes_written += READ_BUFFER
+                @checksum.add_chunk data if chksum?
+              end
+            rescue StandardError => e
+              puts colour.bright_red e.message unless quiet?
+              f.close
+              file_pb.stop if progress?
+              exit 1
+            ensure
+              split_file.close unless split_file.nil?
+              file_pb.increment if progress?
+              @checksum.append_chunk_checksum if chksum?
+            end
+          end
+        end
+
+        file_pb.finish if progress?
+        @checksum.append_file_checksum if chksum?
+
+      end
+
+    end
+
+    protected
+
+    def self.pattern_to_path(pattern, file_path: nil, chunk_number: nil,
+        max_elements: nil, file_number: nil)
+      # Patterns:
+      # {ord} - Original, absolute directory
+      # {orf} - Original filename, with extension
+      # {ore} - File's (last) extension with the lead dot: .jpg
+      # {orb} - File's name without it's extension
+      # {num} - Incremental numbers starting at 1: [1, 2, 3, ...]
+      # {onu} - Incremental numbers starting at 1 and padded with zeros: [01, 02, ... 10, 11]
+      # {gcn} - Incremental numbers starting at 1: [1, 2, 3, ...], used in multi file scenario
+
+      unless file_path.nil?
+        pattern = pattern.gsub(/\{ord\}/i, '%{ord}') % {
+            ord: File.dirname(file_path) }
+
+        pattern = pattern.gsub(/\{orf\}/i, '%{orf}') % {
+            orf: File.basename(file_path) }
+
+        pattern = pattern.gsub(/\{ore\}/i, '%{ore}') % {
+            ore: File.extname(file_path) }
+
+        pattern = pattern.gsub(/\{orb\}/i, '%{orb}') % {
+            orb: File.basename(file_path, File.extname(file_path)) }
+      end
+
+      pattern = pattern.gsub(/\{num\}/i, '%{num}') % {
+          num: chunk_number } unless chunk_number.nil?
+
+      pattern = pattern.gsub(/\{gcn\}/i, '%{gcn}') % {
+          gcn: file_number } unless file_number.nil?
+
+      unless chunk_number.nil? and max_elements.nil?
+        padded_num = chunk_number.to_s.rjust max_elements.to_s.length, '0'
+        pattern    = pattern.gsub(/\{onu\}/i, '%{onu}') % { onu: padded_num }
+      end
+
+      # keep the path clean and valid
+      pattern.gsub "#{File::SEPARATOR}#{File::SEPARATOR}", File::SEPARATOR
+    end
+
+    def size_in_bytes(size_string)
+      case size_string[-1].downcase
+        when 'k'
+          size_string.to_i * 1024
+        when 'm'
+          size_string.to_i * 1024**2
+        when 'g'
+          size_string.to_i * 1024**3
+        else
+          size_string.to_i
+      end
+    end
+
+  end
+end

data/lib/file_replicator/splitter_cmd_parse.rb

@@ -0,0 +1,175 @@
+require_relative 'abstract_cmd_parse'
+
+module FileReplicator
+  class SplitterCmdParse < AbstractCmdParse
+
+    protected
+
+    # Parse ARGV
+    # @return Slop options
+    def parse_argv
+      Slop.parse do |o|
+        o.string '-f', '--files', "Files to split, Ruby's Dir.glob style"
+        o.string '-o', '--output-dir', 'Destination directory, (default: current directory)', default: '.'
+        o.string '-p', '--pattern', 'Output file pattern, details in the --readme (default: {orf}.{onu})', default: '{orf}.{onu}'
+        o.string '-s', '--size', 'Max size of split elements, details in the --readme'
+        o.integer '-e', '--elements', 'Number of parts to split into'
+        o.string '-m', '--min-size', 'Minimal size threshold of a file to consider splitting, details in the --readme'
+        o.string '--checksum', 'Create checksum with the specified algorithm'
+        o.bool '--no-progress', 'Disable progressbar'
+        o.bool '--no-colour', 'Disable colours'
+        o.bool '--quiet', 'Suppress output'
+
+        o.on('--readme', 'Detailed description of some of the parameters and exit') {
+          puts readme
+          exit
+        }
+
+        o.on('--version', 'Display version information and exit') {
+          puts VERSION
+          exit
+        }
+
+        o.on('-h', '--help', 'Display this message') {
+          puts o
+          exit
+        }
+      end
+    end
+
+    def validate(options)
+      validate_files options
+      validate_directory options
+      validate_unknown_split_size options
+      validate_conflicting_split_size options
+      validate_size_format options
+      validate_minimal_size options
+      validate_checksum options
+    end
+
+    # Validates checksum algorithm
+    # @param [Slop] options
+    # @raise ArgumentError
+    def validate_checksum(options)
+      if options.checksum? and !Checksum::SUPPORTED.include?(
+          options[:checksum].downcase.to_sym)
+        msg = "#{options[:checksum]} is not a supported checksum algorithm"
+        raise ArgumentError.new msg
+      end
+    end
+
+    # Validates minimal size's format
+    # @param [Slop] options
+    # @raise ArgumentError
+    def validate_minimal_size(options)
+      if options.min_size? && !options[:min_size].match(/^[\d]+(k|m|g)?$/i)
+        msg = "#{options[:min_size]} is not an acceptable format for minimal size"
+        raise ArgumentError.new msg
+      end
+    end
+
+    # Validates size's format
+    # @param [Slop] options
+    # @raise ArgumentError
+    def validate_size_format(options)
+      if options.size? && !options[:size].match(/^[\d]+(k|m|g)?$/i)
+        msg = "#{options[:size]} is not an acceptable format for split size"
+        raise ArgumentError.new msg
+      end
+    end
+
+    # Check if only either size or number of elements options are used
+    # @param [Slop] options
+    # @raise ConflictingArgumentsExceptions
+    def validate_conflicting_split_size(options)
+      if options.size? and options.elements?
+        msg = 'Choose either size or number of elements (-s or -e)'
+        raise ConflictingArgumentsExceptions.new msg
+      end
+    end
+
+    # Check if size or number of elements options are set
+    # @param [Slop] options
+    # @raise MissingArgumentException
+    def validate_unknown_split_size(options)
+      unless options.size? or options.elements?
+        msg = 'Missing the size or number of elements to split files into (-s or -e)'
+        raise MissingArgumentException.new msg
+      end
+    end
+
+    # Validates the existence of files
+    # @param [Slop] options
+    # @raise MissingArgumentException
+    def validate_files(options)
+      unless options.files?
+        msg = 'Missing list of files to operate on (-f)'
+        raise MissingArgumentException.new msg
+      end
+    end
+
+    # @param [Slop] options
+    # @raise ArgumentError
+    def validate_directory(options)
+      unless options.output_dir?
+        msg = 'Missing output path (-o)'
+        raise MissingArgumentException.new msg
+      end
+    end
+
+    def readme
+      <<-TXT
+
+#{header 'Input file pattern:'}
+
+    To define what file(s) are to be processed you can use Ruby's Dir.glob patterns (https://ruby-doc.org/core-2.3.0/Dir.html#method-c-glob).
+    For this, not to get shells' path translation to interfere, you must put the path pattern in between double (or single) quotes.
+
+    e.g.:
+      $ rsplit -f "/mnt/tv*.mkv"
+    will match a file like: /mnt/tv42.mkv. 
+
+  #{header 'Output file patterns:'}
+
+    Use these building blocks to extract, reuse and add parts to construct output filenames.
+    The patterns are case insensitive and the surrounding curly braces are part of them (see example).
+
+    #{highlight '{ord}'} - Original, absolute directory
+    #{highlight '{orf}'} - Original filename, with extension
+    #{highlight '{ore}'} - File's (last) extension with the lead dot: .jpg
+    #{highlight '{orb}'} - File's name without it's extension
+    #{highlight '{num}'} - Incremental numbers starting at 1: [1, 2, 3, ...]
+    #{highlight '{onu}'} - Incremental numbers starting at 1 and padded with zeros: [01, 02, ... 10, 11]
+    #{highlight '{gcn}'} - Incremental numbers starting at 1: [1, 2, 3, ...], used in multi file scenario
+
+
+  #{header 'Output file sizes:'}
+
+    By default the number used as a file size is in bytes.
+    We can use a more human readable form to specify larger amounts:
+      e.g.: 256k => 256 kilobytes
+
+    Suffixes:
+      - #{highlight 'k'} => kilobyte
+      - #{highlight 'm'} => megabyte
+      - #{highlight 'g'} => gigabyte
+
+  #{header 'Minimal file sizes:'}
+    
+    This option allows us to set a minimal size threshold for files.
+    Files smaller than this threshold will be skipped.
+    We can use a more human readable form to specify larger amounts just like for output sizes.
+
+  #{header 'Supported checksum algorithms:'}
+    - #{highlight 'md5'} #{colour.cyan '(considered broken)'}
+    - #{highlight 'sha1'} #{colour.cyan '(considered broken)'}
+    - #{highlight 'sha224'}
+    - #{highlight 'sha256'}
+    - #{highlight 'sha384'}
+    - #{highlight 'sha512'}
+
+      TXT
+    end
+
+  end
+end

data/lib/file_replicator/version.rb

@@ -0,0 +1,3 @@
+module FileReplicator
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: file-replicator
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Viktor (Icon) VAD
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-12-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.4.1
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+- !ruby/object:Gem::Dependency
+  name: ruby-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.13.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.13.6
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 11.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 11.3.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 5.9.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 5.9.1
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.12
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.12
+description: Command line utility that can split files into chunks, join them together.
+  All is done in binary mode making it encoding independent.
+email:
+- vad.viktor@gmail.com
+executables:
+- rjoin
+- rsplit
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/rjoin
+- exe/rsplit
+- file-split-join-binary.gemspec
+- lib/file_replicator/abstract_cmd_parse.rb
+- lib/file_replicator/checksum.rb
+- lib/file_replicator/exceptions.rb
+- lib/file_replicator/joiner.rb
+- lib/file_replicator/joiner_cmd_parse.rb
+- lib/file_replicator/replicator_helper.rb
+- lib/file_replicator/splitter.rb
+- lib/file_replicator/splitter_cmd_parse.rb
+- lib/file_replicator/version.rb
+homepage: https://github.com/vadviktor/file-replicator
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Split and join files in binary mode
+test_files: []