nucleus 0.1.0 → 0.2.0

data/lib/nucleus/core/common/files/archive_extractor.rb

@@ -1,112 +1,112 @@
-module Nucleus
-  class ArchiveExtractor
-    def initialize(exclude_git = true)
-      @exclude_git = exclude_git
-    end
-
-    # Extract the file to the destination path.
-    # The compression format indicates which method must be used to extract the archive.
-    # @param [IO] file in-memory archive file to extract
-    # @param [String] destination_path where the archive is going to be extracted to
-    # @param [String] compression_format represented by well-known file extensions, e.g. zip or tar.gz
-    # @raise [StandardError] if the compression_format is not supported and can't be extracted
-    # @return [Integer] number of extracted files
-    def extract(file, destination_path, compression_format)
-      compression_method = compression_format_method_name(compression_format)
-      fail StandardError, 'Unsupported compression format' unless respond_to?(compression_method, true)
-
-      # be sure that directory exists
-      FileUtils.mkdir_p(destination_path, verbose: false)
-
-      begin
-        send(compression_method, file, destination_path)
-      rescue Zip::Error, Zlib::GzipFile::Error
-        raise API::Errors::ApplicationArchiveError, "Failed to extract #{compression_format} archive"
-      end
-    end
-
-    # Checks if the compression format is supported and an archive of this type could be extracted.
-    # @param [String] compression_format represented by well-known file extensions, e.g. zip or tar.gz
-    # @return [Boolean] true if format is supported, false if not
-    def supports?(compression_format)
-      compression_method = compression_format_method_name(compression_format)
-      respond_to?(compression_method, true)
-    end
-
-    private
-
-    def compression_format_method_name(compression_format)
-      "un_#{compression_format.downcase.gsub(/\./, '_').underscore}".to_sym
-    end
-
-    def un_zip(file, destination_path)
-      extracted = 0
-      Zip::File.open(file) do |zip_file|
-        # Handle entries one by one
-        zip_file.each do |entry|
-          next if @exclude_git && entry.name.start_with?('.git')
-          dest = File.join(destination_path, entry.name)
-          if entry.name_is_directory?
-            FileUtils.mkdir_p(dest) unless File.exist?(dest)
-          else
-            # make sure parent directory exists
-            FileUtils.mkdir_p(File.expand_path('..', dest))
-
-            entry.extract(dest) unless File.exist?(dest)
-            # increase count
-            extracted += 1
-          end
-        end
-      end
-      extracted
-    end
-
-    def un_tar_gz(file, destination_path)
-      extracted = 0
-      # unzip the archive into the repo, closes resource automatically
-      # Thanks to Draco Ater: http://stackoverflow.com/a/19139114/1009436
-      Gem::Package::TarReader.new(Zlib::GzipReader.open(file)) do |tar|
-        dest = nil
-        tar.each do |entry|
-          # Process Longlinks and skip to next entry
-          if entry.full_name == '././@LongLink'
-            dest = File.join(destination_path, entry.read.strip)
-            next
-          end
-
-          # Process default entry types (dir, file, symlink)
-          full_name = entry.full_name.sub(%r{(\.\/)?}, '')
-          dest ||= File.join(destination_path, full_name)
-          next if tar_git_entry? full_name
-          if entry.directory?
-            write_tar_dir_entry(entry, dest)
-          elsif entry.file?
-            write_tar_file_entry(entry, dest)
-            # increase count
-            extracted += 1
-          elsif entry.header.typeflag == '2'
-            # handle symlinks
-            File.symlink(entry.header.linkname, dest)
-          end
-          dest = nil
-        end
-      end
-    end
-    alias_method :un_tgz, :un_tar_gz
-
-    def tar_git_entry?(full_name)
-      @exclude_git && (full_name.start_with?('._.git') || full_name.start_with?('.git'))
-    end
-
-    def write_tar_file_entry(entry, dest)
-      FileUtils.rm_rf(dest) if File.directory?(dest)
-      File.open(dest, 'wb') { |f| f.print entry.read }
-      FileUtils.chmod(entry.header.mode, dest, verbose: false)
-    end
-
-    def write_tar_dir_entry(entry, dest)
-      File.delete(dest) if File.file?(dest)
-      FileUtils.mkdir_p(dest, mode: entry.header.mode, verbose: false)
-    end
-  end
-end
+module Nucleus
+  class ArchiveExtractor
+    def initialize(exclude_git = true)
+      @exclude_git = exclude_git
+    end
+
+    # Extract the file to the destination path.
+    # The compression format indicates which method must be used to extract the archive.
+    # @param [IO] file in-memory archive file to extract
+    # @param [String] destination_path where the archive is going to be extracted to
+    # @param [String] compression_format represented by well-known file extensions, e.g. zip or tar.gz
+    # @raise [StandardError] if the compression_format is not supported and can't be extracted
+    # @return [Integer] number of extracted files
+    def extract(file, destination_path, compression_format)
+      compression_method = compression_format_method_name(compression_format)
+      fail StandardError, 'Unsupported compression format' unless respond_to?(compression_method, true)
+
+      # be sure that directory exists
+      FileUtils.mkdir_p(destination_path, verbose: false)
+
+      begin
+        send(compression_method, file, destination_path)
+      rescue Zip::Error, Zlib::GzipFile::Error
+        raise API::Errors::ApplicationArchiveError, "Failed to extract #{compression_format} archive"
+      end
+    end
+
+    # Checks if the compression format is supported and an archive of this type could be extracted.
+    # @param [String] compression_format represented by well-known file extensions, e.g. zip or tar.gz
+    # @return [Boolean] true if format is supported, false if not
+    def supports?(compression_format)
+      compression_method = compression_format_method_name(compression_format)
+      respond_to?(compression_method, true)
+    end
+
+    private
+
+    def compression_format_method_name(compression_format)
+      "un_#{compression_format.downcase.tr('.', '_').underscore}".to_sym
+    end
+
+    def un_zip(file, destination_path)
+      extracted = 0
+      Zip::File.open(file) do |zip_file|
+        # Handle entries one by one
+        zip_file.each do |entry|
+          next if @exclude_git && entry.name.start_with?('.git')
+          dest = File.join(destination_path, entry.name)
+          if entry.name_is_directory?
+            FileUtils.mkdir_p(dest) unless File.exist?(dest)
+          else
+            # make sure parent directory exists
+            FileUtils.mkdir_p(File.expand_path('..', dest))
+
+            entry.extract(dest) unless File.exist?(dest)
+            # increase count
+            extracted += 1
+          end
+        end
+      end
+      extracted
+    end
+
+    def un_tar_gz(file, destination_path)
+      extracted = 0
+      # unzip the archive into the repo, closes resource automatically
+      # Thanks to Draco Ater: http://stackoverflow.com/a/19139114/1009436
+      Gem::Package::TarReader.new(Zlib::GzipReader.open(file)) do |tar|
+        dest = nil
+        tar.each do |entry|
+          # Process Longlinks and skip to next entry
+          if entry.full_name == '././@LongLink'
+            dest = File.join(destination_path, entry.read.strip)
+            next
+          end
+
+          # Process default entry types (dir, file, symlink)
+          full_name = entry.full_name.sub(%r{(\.\/)?}, '')
+          dest ||= File.join(destination_path, full_name)
+          next if tar_git_entry? full_name
+          if entry.directory?
+            write_tar_dir_entry(entry, dest)
+          elsif entry.file?
+            write_tar_file_entry(entry, dest)
+            # increase count
+            extracted += 1
+          elsif entry.header.typeflag == '2'
+            # handle symlinks
+            File.symlink(entry.header.linkname, dest)
+          end
+          dest = nil
+        end
+      end
+    end
+    alias un_tgz un_tar_gz
+
+    def tar_git_entry?(full_name)
+      @exclude_git && full_name.start_with?('._.git', '.git')
+    end
+
+    def write_tar_file_entry(entry, dest)
+      FileUtils.rm_rf(dest) if File.directory?(dest)
+      File.open(dest, 'wb') { |f| f.print entry.read }
+      FileUtils.chmod(entry.header.mode, dest, verbose: false)
+    end
+
+    def write_tar_dir_entry(entry, dest)
+      File.delete(dest) if File.file?(dest)
+      FileUtils.mkdir_p(dest, mode: entry.header.mode, verbose: false)
+    end
+  end
+end

data/lib/nucleus/core/common/files/archiver.rb

@@ -1,91 +1,91 @@
-module Nucleus
-  class Archiver
-    def initialize(exclude_git = true)
-      @exclude_git = exclude_git
-    end
-
-    # Compress the files of the path into an archive, using the compression format,
-    # which indicates which method must be used to compress the archive.
-    # @param [String] path which directory's contents are going to be compressed into the archive
-    # @param [String] compression_format represented by well-known file extensions, e.g. zip or tar.gz
-    # @raise [StandardError] if the compression_format is not supported and the directory can't be compressed
-    # @return [StringIO] compressed data of the given input path
-    def compress(path, compression_format)
-      compression_method = compression_format.downcase.gsub(/\./, '_').underscore.to_sym
-      fail StandardError,
-           "Unsupported compression format #{compression_format}" unless self.respond_to?(compression_method, true)
-      send(compression_method, path)
-    end
-
-    private
-
-    def tar(path)
-      string_io = StringIO.new('')
-      Gem::Package::TarWriter.new(string_io) do |tar|
-        Find.find(path) do |file|
-          # do not include the git files
-          next if @exclude_git && file.start_with?("#{path}/.git")
-
-          mode = File.stat(file).mode
-          relative_file = file.sub(%r{^#{Regexp.escape path}\/?}, '')
-
-          if File.directory?(file)
-            tar.mkdir relative_file, mode
-          else
-            tar.add_file relative_file, mode do |tf|
-              File.open(file, 'rb') { |f| tf.write f.read }
-            end
-          end
-        end
-      end
-      string_io.rewind
-      string_io
-    end
-
-    def tar_gz(path)
-      tar_file = tar(path)
-      begin
-        gz = StringIO.new('')
-        z = Zlib::GzipWriter.new(gz)
-        z.write tar_file.string
-      ensure
-        z.close unless z.nil?
-      end
-
-      # z was closed to write the gzip footer, so
-      # now we need a new StringIO
-      StringIO.new gz.string
-    end
-
-    def zip(path)
-      string_io = Zip::OutputStream.write_buffer do |zio|
-        Find.find(path) do |file|
-          # do not process directories && do not include the Git DB files
-          next if File.directory?(file) || (@exclude_git && file.start_with?("#{path}/.git"))
-
-          relative_file = file.sub(%r{^#{Regexp.escape path}\/?}, '')
-          zio.put_next_entry(relative_file)
-          File.open(file, 'rb') do |f|
-            zio.write f.read
-          end
-        end
-      end
-      string_io.rewind
-      string_io
-    end
-
-    def write_zip_entries(path, sub_path, io)
-      search_path = File.join(path, sub_path)
-      Find.find(path) do |file|
-        zip_file_path = file.sub(%r{^#{Regexp.escape search_path}\/?}, '')
-        next if @exclude_git && zip_file_path.start_with?('.git')
-        if File.directory?(file)
-          io.mkdir(zip_file_path)
-          write_zip_entries(path, zip_file_path, io)
-        else
-          io.get_output_stream(zip_file_path) { |f| f.print(File.open(file, 'rb').read) }
-        end
-      end
-    end
-  end
-end
+module Nucleus
+  class Archiver
+    def initialize(exclude_git = true)
+      @exclude_git = exclude_git
+    end
+
+    # Compress the files of the path into an archive, using the compression format,
+    # which indicates which method must be used to compress the archive.
+    # @param [String] path which directory's contents are going to be compressed into the archive
+    # @param [String] compression_format represented by well-known file extensions, e.g. zip or tar.gz
+    # @raise [StandardError] if the compression_format is not supported and the directory can't be compressed
+    # @return [StringIO] compressed data of the given input path
+    def compress(path, compression_format)
+      compression_method = compression_format.downcase.tr('.', '_').underscore.to_sym
+      fail StandardError,
+           "Unsupported compression format #{compression_format}" unless respond_to?(compression_method, true)
+      send(compression_method, path)
+    end
+
+    private
+
+    def tar(path)
+      string_io = StringIO.new('')
+      Gem::Package::TarWriter.new(string_io) do |tar|
+        Find.find(path) do |file|
+          # do not include the git files
+          next if @exclude_git && file.start_with?("#{path}/.git")
+
+          mode = File.stat(file).mode
+          relative_file = file.sub(%r{^#{Regexp.escape path}\/?}, '')
+
+          if File.directory?(file)
+            tar.mkdir relative_file, mode
+          else
+            tar.add_file relative_file, mode do |tf|
+              File.open(file, 'rb') { |f| tf.write f.read }
+            end
+          end
+        end
+      end
+      string_io.rewind
+      string_io
+    end
+
+    def tar_gz(path)
+      tar_file = tar(path)
+      begin
+        gz = StringIO.new('')
+        z = Zlib::GzipWriter.new(gz)
+        z.write tar_file.string
+      ensure
+        z.close unless z.nil?
+      end
+
+      # z was closed to write the gzip footer, so
+      # now we need a new StringIO
+      StringIO.new gz.string
+    end
+
+    def zip(path)
+      string_io = Zip::OutputStream.write_buffer do |zio|
+        Find.find(path) do |file|
+          # do not process directories && do not include the Git DB files
+          next if File.directory?(file) || (@exclude_git && file.start_with?("#{path}/.git"))
+
+          relative_file = file.sub(%r{^#{Regexp.escape path}\/?}, '')
+          zio.put_next_entry(relative_file)
+          File.open(file, 'rb') do |f|
+            zio.write f.read
+          end
+        end
+      end
+      string_io.rewind
+      string_io
+    end
+
+    def write_zip_entries(path, sub_path, io)
+      search_path = File.join(path, sub_path)
+      Find.find(path) do |file|
+        zip_file_path = file.sub(%r{^#{Regexp.escape search_path}\/?}, '')
+        next if @exclude_git && zip_file_path.start_with?('.git')
+        if File.directory?(file)
+          io.mkdir(zip_file_path)
+          write_zip_entries(path, zip_file_path, io)
+        else
+          io.get_output_stream(zip_file_path) { |f| f.print(File.open(file, 'rb').read) }
+        end
+      end
+    end
+  end
+end

data/lib/nucleus/core/common/logging/request_log_formatter.rb

@@ -1,48 +1,48 @@
-require 'English'
-
-module Nucleus
-  module Logging
-    class Formatter
-      FORMAT = "%s, %38s [%s#%d] %5s -- %s: %s\n"
-
-      attr_accessor :datetime_format
-
-      def initialize
-        @datetime_format = nil
-      end
-
-      def call(severity, time, progname, msg)
-        if Thread.current[:nucleus_request_id].nil?
-          # if there is no request id, then fill up the space
-          request_part = "[#{'*' * 36}]"
-        else
-          request_part = "[#{Thread.current[:nucleus_request_id]}]"
-        end
-
-        format(FORMAT, severity[0..0], request_part, format_datetime(time),
-               $PID, severity, progname, msg2str(msg))
-      end
-
-      private
-
-      def format_datetime(time)
-        if @datetime_format.nil?
-          format(time.strftime('%Y-%m-%dT%H:%M:%S.') << '%06d ', time.usec)
-        else
-          time.strftime(@datetime_format)
-        end
-      end
-
-      def msg2str(msg)
-        case msg
-        when ::String
-          msg
-        when ::Exception
-          "#{msg.message} (#{msg.class})\n" << (msg.backtrace || []).join("\n")
-        else
-          msg.inspect
-        end
-      end
-    end
-  end
-end
+require 'English'
+
+module Nucleus
+  module Logging
+    class Formatter
+      FORMAT = "%s, %38s [%s#%d] %5s -- %s: %s\n".freeze
+
+      attr_accessor :datetime_format
+
+      def initialize
+        @datetime_format = nil
+      end
+
+      def call(severity, time, progname, msg)
+        request_part = if Thread.current[:nucleus_request_id].nil?
+                         # if there is no request id, then fill up the space
+                         "[#{'*' * 36}]"
+                       else
+                         "[#{Thread.current[:nucleus_request_id]}]"
+                       end
+
+        format(FORMAT, severity[0..0], request_part, format_datetime(time),
+               $PID, severity, progname, msg2str(msg))
+      end
+
+      private
+
+      def format_datetime(time)
+        if @datetime_format.nil?
+          format(time.strftime('%Y-%m-%dT%H:%M:%S.') << '%06d ', time.usec)
+        else
+          time.strftime(@datetime_format)
+        end
+      end
+
+      def msg2str(msg)
+        case msg
+        when ::String
+          msg
+        when ::Exception
+          "#{msg.message} (#{msg.class})\n" << (msg.backtrace || []).join("\n")
+        else
+          msg.inspect
+        end
+      end
+    end
+  end
+end