file_concat 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 198a116a58d9ed469952ec470a1b6064901f1875db1076aca5f176e87d01790c
+  data.tar.gz: 989eb7b0018689221c2fc5aadd59018f9a5872bbc7ddce6277005e529e31732f
+SHA512:
+  metadata.gz: 43fd08c2591869ece5691b8fa66498a031c74018cfc7a0f38da93e826e309d46497ec51b43aad36a08462b495f655aff5661d9e93c17602f36f0ad8bfced44d8
+  data.tar.gz: ae728c63b06ad5229cca07f7b3ac0f5c5a1a8763713cc21fe50f656d83b9e87a228e38416df867af2d2767ed1942c7e67da25c5614d713f8a43e42d21910f4bb

data/lib/file_concat.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Namespace for our Gem.  This is the root of all of the functionality and the
+# base name for all of our individual classes that contain extended, specific,
+# etc. logic.
+class FileConcat
+
+end
+
+require 'file_concat/simple_concat'
+require 'file_concat/pre_post_concat'

data/lib/file_concat/pre_post_concat.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+class FileConcat
+  # A more complex file concatenation allowing for the use of some pre and post
+  # processing functionality during the actual run.  We do our best to rely on
+  # the file system wherever possible so we can use the I/O optimization that is
+  # written by the experts.
+  class PrePostConcat
+
+    attr_reader :batch_count
+
+    attr_accessor :batch_first_line
+    attr_accessor :file_first_line
+    attr_accessor :file_last_line
+    attr_accessor :batch_last_line
+
+    # ==== This method does:
+    #
+    # Creates a new instance of our PrePostConcat processor.
+    #
+    # ==== With params:
+    #
+    # @param file_provider <Proc> - the provider of files to concatenate
+    # @param target_dir <String> - the path to store the batch files in
+    # @param target_ext <String> - the extension for the batch files
+    # @param batch_size <Integer> - the total number of files to concatenate into one
+    #
+    # ==== And returns:
+    #
+    # @return batch_count <Integer> - the total number of batch files created
+    #
+    # ==== And is used like:
+    #
+    # FileBatcher.new my_proc, '/path/to/output', 'xml', 25
+    #
+    def initialize(file_provider, target_dir, target_ext, batch_size)
+      @file_provider = file_provider
+      @target_dir = target_dir
+      @target_ext = target_ext
+      @batch_size = batch_size
+      @batch_count = 0
+    end
+
+    # ==== This method does:
+    #
+    # Actually executes file concatenation.
+    #
+    # ==== With params:
+    #
+    # N/A
+    #
+    # ==== And returns:
+    #
+    # @return batch_count <Integer> - the total number of batch files created
+    #
+    # ==== And is used like:
+    #
+    # batches = instance.run
+    #
+    def run
+      # reset the batch count
+      @batch_count = 0
+
+      # if the target doesn't exist, create it... if it does, empty it
+      FileUtils.remove_dir @target_dir if Dir.exist? @target_dir
+      Dir.mkdir @target_dir
+
+      # loop over all the files
+      current_file_index = 0
+      active_batch_file = nil
+
+      @file_provider.call.each do |next_file|
+        # create a new file to concatenate to
+        current_file_index += 1
+        if (current_file_index - 1) % @batch_size == 0
+          @batch_count += 1
+          end_batch_file(active_batch_file) unless active_batch_file.nil?
+          active_batch_file = new_batch_file
+        end
+
+        # concatenate the file
+        concat_to active_batch_file, next_file
+      end
+      end_batch_file(active_batch_file) unless active_batch_file.nil?
+
+      # return the batch count
+      @batch_count
+    end
+
+    private
+
+    # ==== This method does:
+    #
+    # Sets up the new batch file to use for processing.
+    #
+    # ==== With params:
+    #
+    # N/A
+    #
+    # ==== And returns:
+    #
+    # @return file_path <File> - the complete path to the next batch file
+    #
+    # ==== And is used like:
+    #
+    # next_file = instance.new_batch_file(@batch_count)
+    #
+    def new_batch_file
+      # basic setup
+      formatted_index = batch_count.to_s.rjust(5, '0')
+      file_name = "Batch-#{formatted_index}.#{@target_ext}"
+      file_path = File.join(@target_dir, file_name)
+
+      # if we have a batch first line, use it
+      unless batch_first_line.nil?
+        first_line = batch_first_line.call(file_name)
+        File.open(file_path, 'w') { |f| f.puts first_line } unless first_line.nil?
+      end
+
+      # exit
+      file_path
+    end
+
+    # ==== This method does:
+    #
+    # Ends a batch file.
+    #
+    # ==== With params:
+    #
+    # @param file <File> - the actual file we are ending work with
+    #
+    # ==== And returns:
+    #
+    # N/A
+    #
+    # ==== And is used like:
+    #
+    # instance.end_batch_file(active_batch_file)
+    #
+    def end_batch_file(file)
+      unless batch_last_line.nil?
+        last_line = batch_last_line.call(file)
+        File.open(file, 'a') { |f| f.puts last_line } unless last_line.nil?
+      end
+    end
+
+    # ==== This method does:
+    #
+    # Concatenates the source file to the target file.
+    #
+    # ==== With params:
+    #
+    # @param target_file <File> - the file to concatenate the other to
+    # @param source_file <String> - path to the file to concatenate to the other
+    #
+    # ==== And returns:
+    #
+    # N/A
+    #
+    # ==== And is used like:
+    #
+    # instance.concat_to(target_file, source_file)
+    #
+    def concat_to(target_file, source_file)
+      # get the first line
+      first_line = file_first_line.nil? ? nil : file_first_line.call(source_file)
+      File.open(target_file, 'a') { |f| f.puts first_line } unless blank? first_line
+
+      # concat the file
+      system("cat \"#{source_file}\" >> \"#{target_file}\"")
+      exit_code = $?.exitstatus
+      raise StandardError, "Error concatenating files : Target[#{target_file}], Source[#{source_file}]" unless exit_code.zero?
+
+      # get the last line
+      last_line = file_last_line.nil? ? nil : file_last_line.call(source_file)
+      File.open(target_file, 'a') { |f| f.puts last_line } unless blank? last_line
+    end
+
+    # ==== This method does:
+    #
+    # Utility method to test if strings are empty.
+    #
+    # ==== With params:
+    #
+    # @param string <String> - the string to test
+    #
+    # ==== And returns:
+    #
+    # @return blank <Boolean> whether or not the string is blank
+    #
+    # ==== And is used like:
+    #
+    # blank? 'something'
+    #
+    def blank?(string)
+      string.to_s.strip.empty?
+    end
+  end
+end

data/lib/file_concat/simple_concat.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class FileConcat
+  # Simple file concatenation that performs a no-thrills operation.  Friendly
+  # to small and large amounts of files, this is extremely basic and uses the
+  # underlying filesystem to do the actual heavy lifting (there's code written
+  # by the I/O experts for this, so don't reinvent the wheel).
+  class SimpleConcat
+    # TODO: all this
+  end
+end

data/lib/file_concat/version.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module FileConcat
+  # Pulls the current version of the library.
+  class Version
+    # ==== This method does:
+    #
+    # Retrieves the version of the library.
+    #
+    # ==== With params:
+    #
+    # N/A
+    #
+    # ==== And returns:
+    #
+    # @return version <String> - the version of the library
+    #
+    # ==== And is used like:
+    #
+    # FileConcat::Version.version
+    #
+    def self.version
+      File.read('VERSION').strip
+    end
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: file_concat
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Joe Brutto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-04 00:00:00.000000000 Z
+dependencies: []
+description: File concatenation library for Ruby with some simple options and some
+  complex options.
+email: open.source@revof11.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/file_concat.rb
+- lib/file_concat/pre_post_concat.rb
+- lib/file_concat/simple_concat.rb
+- lib/file_concat/version.rb
+homepage: https://gitlab.com/joe.brutto/ruby-file-concat
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://gitlab.com/joe.brutto/ruby-file-concat/issues
+  documentation_uri: https://gitlab.com/joe.brutto/ruby-file-concat/wikis/home1
+  source_code_uri: https://gitlab.com/joe.brutto/ruby-file-concat/tree/master
+  wiki_uri: https://gitlab.com/joe.brutto/ruby-file-concat/wikis/home1
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- Unix-like OS
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: file_concat
+test_files: []