eac_tools 0.3.0 → 0.6.0

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/ssh_env/terminal.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'eac_ruby_utils/envs/ssh_env/dasho_options'
+require 'eac_ruby_utils/listable'
+require 'eac_ruby_utils/patches/object/if_present'
+
+module EacRubyUtils
+  module Envs
+    class SshEnv < ::EacRubyUtils::Envs::BaseEnv
+      module Terminal
+        extend ::ActiveSupport::Concern
+
+        included do
+          include ::EacRubyUtils::Envs::SshEnv::DashoOptions
+          add_nodasho_option('Terminal')
+          include ::EacRubyUtils::Listable
+          lists.add_string :terminal_option, :auto, :disable, :enable, :force
+        end
+
+        def ssh_command_line_terminal_args(value)
+          self.class.lists.terminal_option.value_validate!(value)
+          case value
+          when TERMINAL_OPTION_AUTO then ENV['TERM'].present? ? %w[-t] : []
+          when TERMINAL_OPTION_DISABLE then ['-T']
+          when TERMINAL_OPTION_ENABLE then ['-t']
+          when TERMINAL_OPTION_FORCE then ['-tt']
+          else raise "Invalid conditional branch: #{value}"
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/ssh_env.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'addressable'
+require 'eac_ruby_utils/envs/base_env'
+require 'eac_ruby_utils/patches/object/if_present'
+require 'eac_ruby_utils/patches/module/require_sub'
+require 'net/ssh'
+require 'shellwords'
+
+module EacRubyUtils
+  module Envs
+    class SshEnv < ::EacRubyUtils::Envs::BaseEnv
+      require_sub __FILE__, include_modules: true
+
+      USER_PATTERN = /[a-z_][a-z0-9_-]*/.freeze
+      HOSTNAME_PATTERN = /[^@]+/.freeze
+      USER_HOSTNAME_PATTERN = /\A(?:(#{USER_PATTERN})@)?(#{HOSTNAME_PATTERN})\z/.freeze
+
+      class << self
+        def parse_uri(uri)
+          uri_by_url(uri) || uri_by_user_hostname(uri) || raise("URI has no SSH scheme: #{uri}")
+        end
+
+        private
+
+        def uri_by_url(url)
+          r = ::Addressable::URI.parse(url)
+          r.scheme == 'ssh' && r.host.present? ? r : nil
+        end
+
+        def uri_by_user_hostname(user_hostname)
+          m = USER_HOSTNAME_PATTERN.match(user_hostname)
+          m ? ::Addressable::URI.new(scheme: 'ssh', host: m[2], user: m[1]) : nil
+        rescue Addressable::URI::InvalidURIError
+          nil
+        end
+      end
+
+      attr_reader :uri
+
+      def initialize(uri)
+        @uri = self.class.parse_uri(uri).freeze
+      end
+
+      def to_s
+        uri.to_s
+      end
+
+      def command_line(line)
+        "#{ssh_command_line} #{Shellwords.escape(line)}"
+      end
+
+      private
+
+      def ssh_command_line
+        (%w[ssh] +
+          %w[nodasho dasho port].flat_map { |m| send("ssh_command_line_#{m}_args") } +
+          [user_hostname_uri])
+          .map { |a| Shellwords.escape(a) }.join(' ')
+      end
+
+      def ssh_command_line_port_args
+        uri.port.if_present([]) do |v|
+          ['-p', v]
+        end
+      end
+
+      def user_hostname_uri
+        r = uri.host
+        r = "#{uri.user}@#{r}" if uri.user.present?
+        r
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/envs/base_env'
+require 'eac_ruby_utils/envs/command'
+require 'eac_ruby_utils/envs/file'
+require 'eac_ruby_utils/envs/local_env'
+require 'eac_ruby_utils/envs/process'
+require 'eac_ruby_utils/envs/ssh_env'
+require 'eac_ruby_utils/envs/executable'
+
+module EacRubyUtils
+  module Envs
+    class << self
+      def local
+        @local ||= ::EacRubyUtils::Envs::LocalEnv.new
+      end
+
+      def ssh(user_hostname)
+        ::EacRubyUtils::Envs::SshEnv.new(user_hostname)
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/fs/clearable_directory.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'pathname'
+
+module EacRubyUtils
+  module Fs
+    class ClearableDirectory < ::Pathname
+      CLEARABLE_BASENAME = '.clearable_directory'
+
+      def clear
+        validate_clearable
+        directory? ? clear_directory : clear_no_directory
+        mkpath
+        ::FileUtils.touch(clearable_note_file.to_path)
+        self
+      end
+
+      def clearable?
+        clearable_negate_message ? true : false
+      end
+
+      def clearable_negate_message
+        return if !exist? || empty?
+        return "Path \"#{self}\" exists, is not empty and is not a directory" unless directory?
+        return if clearable_note_file.exist?
+
+        "Directory \"#{self}\" is not empty and does not have a #{CLEARABLE_BASENAME} file"
+      end
+
+      def clearable_note_file
+        join(CLEARABLE_BASENAME)
+      end
+
+      def validate_clearable
+        message = clearable_negate_message
+        raise message if message
+      end
+
+      private
+
+      def clear_directory
+        children.each do |child|
+          if child.directory?
+            child.rmtree
+          elsif child.file?
+            child.unlink
+          end
+        end
+      end
+
+      def clear_no_directory
+        ::FileUtils.rm_rf(to_path)
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/fs/extname.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Fs
+    class << self
+      # A [File.extname] which find multiple extensions (Ex.: .tar.gz).
+      def extname(path, limit = -1)
+        recursive_extension(::File.basename(path), limit)
+      end
+
+      # Shortcut to +extname(2)+.
+      def extname2(path)
+        extname(path, 2)
+      end
+
+      private
+
+      def recursive_extension(basename, limit)
+        return '' if limit.zero?
+
+        m = /\A(.+)(\.[a-z][a-z0-9]*)\z/i.match(basename)
+        if m
+          "#{recursive_extension(m[1], limit - 1)}#{m[2]}"
+        else
+          ''
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/fs/temp/directory.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/fs/temp/file'
+
+module EacRubyUtils
+  module Fs
+    module Temp
+      class Directory < ::EacRubyUtils::Fs::Temp::File
+        def initialize(*tempfile_args)
+          super(*tempfile_args)
+          mkpath
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/fs/temp/file.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'tempfile'
+
+module EacRubyUtils
+  module Fs
+    module Temp
+      class File < Pathname
+        # Temporary file
+        def initialize(*tempfile_args)
+          file = Tempfile.new(*tempfile_args)
+          path = file.path
+          file.close
+          file.unlink
+          super(path)
+        end
+
+        def remove
+          if directory?
+            rmtree
+          elsif file?
+            unlink
+          end
+        end
+
+        def remove!
+          remove
+          raise "Tried to remove \"#{self}\", but it yet exists" if exist?
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/fs/temp.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+require 'pathname'
+require 'tempfile'
+
+module EacRubyUtils
+  module Fs
+    # Utilities for temporary files.
+    module Temp
+      class << self
+        ::EacRubyUtils.require_sub __FILE__
+
+        # Shortcut to +EacRubyUtils::Fs::Temp::Directory.new(*tempfile_args)+.
+        #
+        # @return [Pathname]
+        def directory(*tempfile_args)
+          ::EacRubyUtils::Fs::Temp::Directory.new(*tempfile_args)
+        end
+
+        # Shortcut to +EacRubyUtils::Fs::Temp::File.new(*tempfile_args)+.
+        #
+        # @return [Pathname]
+        def file(*tempfile_args)
+          ::EacRubyUtils::Fs::Temp::File.new(*tempfile_args)
+        end
+
+        # Run a block while a temporary directory pathname is provided. The directory is deleted
+        # when the block is finished.
+        def on_directory(*tempfile_args)
+          temp_dir = directory(*tempfile_args)
+          begin
+            yield(temp_dir)
+          ensure
+            temp_dir.remove
+          end
+        end
+
+        # Run a block while a temporary file pathname is providade. The file is deleted when block
+        # is finished.
+        def on_file(*tempfile_args)
+          temp_file = file(*tempfile_args)
+          begin
+            yield(temp_file)
+          ensure
+            temp_file.remove
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/fs.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+
+module EacRubyUtils
+  module Fs
+    ::EacRubyUtils.require_sub __FILE__
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/gems_registry/gem.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require 'eac_ruby_utils/recursive_builder'
+require 'eac_ruby_utils/simple_cache'
+
+module EacRubyUtils
+  class GemsRegistry
+    class Gem
+      include ::Comparable
+      include ::EacRubyUtils::SimpleCache
+
+      attr_reader :registry, :gemspec
+
+      def initialize(registry, gemspec)
+        @registry = registry
+        @gemspec = gemspec
+      end
+
+      def depend_on(gem)
+        dependencies.lazy.map(&:name).include?(gem.gemspec.name)
+      end
+
+      def dependencies
+        @dependencies ||= dependencies_uncached # dependencies_uncached
+      end
+
+      def <=>(other)
+        sd = depend_on(other)
+        od = other.depend_on(self)
+        return 1 if sd && !od
+        return -1 if od && !sd
+
+        gemspec.name <=> other.gemspec.name
+      end
+
+      def found?
+        lib_file_found? && registered_module.is_a?(::Module)
+      end
+
+      def lib_file_found?
+        gemspec.require_paths.any? do |require_path|
+          ::Pathname.new(require_path).expand_path(gemspec.gem_dir).join(path_to_require + '.rb')
+            .file?
+        end
+      end
+
+      def registered_module
+        return nil unless lib_file_found?
+
+        require path_to_require
+        path_to_require.classify.constantize
+      end
+
+      # @return [String]
+      def path_to_require
+        gemspec.name.gsub('-', '/') + '/' + registry.module_suffix.underscore
+      end
+
+      def to_s
+        "#{self.class.name}[#{gemspec.name}]"
+      end
+
+      private
+
+      def dependencies_uncached
+        ::EacRubyUtils::RecursiveBuilder
+          .new(gemspec) { |item| gem_item_dependencies(item) }
+          .result
+      end
+
+      def gem_item_dependencies(item)
+        ::Gem::Specification.find_by_name(item.name).dependencies
+      rescue ::Gem::MissingSpecError
+        []
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/gems_registry.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'eac_ruby_utils/gems_registry/gem'
+
+module EacRubyUtils
+  # Search in each gem for a class determined by registry and run the method "register" on each
+  # found.
+  #
+  # Example:
+  # * The module suffix is `TheClass`;
+  # * A gem with name "my-lib" is being analyzed
+  # * If a require for "my/lib/the_class" is succesful the class/module `My::Lib::TheClass` will
+  #   be collected.
+  class GemsRegistry
+    attr_reader :module_suffix
+
+    def initialize(module_suffix)
+      @module_suffix = module_suffix
+    end
+
+    # @return [Array<EacRubyUtils::GemsRegistry::Gem>]
+    def registered
+      @registered ||= all_gems.select(&:found?).sort
+    end
+
+    private
+
+    # @return [Array<EacRubyUtils::GemsRegistry::Gem>]
+    def all_gems
+      ::Gem::Specification.map { |gemspec| ::EacRubyUtils::GemsRegistry::Gem.new(self, gemspec) }
+        .sort
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/immutable/array_accessor.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+require 'eac_ruby_utils/immutable/base_accessor'
+require 'eac_ruby_utils/patches/class/common_constructor'
+
+module EacRubyUtils
+  module Immutable
+    class ArrayAccessor < ::EacRubyUtils::Immutable::BaseAccessor
+      def apply(klass)
+        accessor = self
+        klass.send(:define_method, name) do |value|
+          accessor.immutable_value_set(self, value)
+        end
+
+        klass.send(:define_method, ::ActiveSupport::Inflector.pluralize(name)) do
+          accessor.immutable_value_get(self)
+        end
+      end
+
+      def immutable_value_get(object)
+        super || []
+      end
+
+      def immutable_value_set(object, value)
+        duplicate_object(object) do |old_value|
+          (old_value || []) + [value]
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/immutable/base_accessor.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Immutable
+    class BaseAccessor
+      common_constructor :name do
+        self.name = name.to_sym
+      end
+
+      def duplicate_object(object)
+        accessor_new_value = yield(immutable_value_get(object))
+        new_values = object.send(:immutable_values_get).merge(name => accessor_new_value)
+        r = object.class.new(*object.immutable_constructor_args)
+        r.send(:immutable_values_set, new_values)
+        r
+      end
+
+      def immutable_value_get(object)
+        object.send(:immutable_values_get)[name]
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/immutable/boolean_accessor.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/immutable/common_accessor'
+require 'eac_ruby_utils/patches/class/common_constructor'
+
+module EacRubyUtils
+  module Immutable
+    class BooleanAccessor < ::EacRubyUtils::Immutable::CommonAccessor
+      def apply(klass)
+        super
+        accessor = self
+        klass.send(:define_method, "#{name}?") { send(accessor.name) }
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/immutable/class_methods.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Immutable
+    module ClassMethods
+      def immutable_accessor(*accessors)
+        options = accessors.extract_options!
+        options[:type] ||= const_get('TYPE_COMMON')
+        accessors.each do |name|
+          class_name = options.fetch(:type).to_s.camelize + 'Accessor'
+          ::EacRubyUtils::Immutable.const_get(class_name).new(name).apply(self)
+        end
+      end
+
+      private
+
+      def imutable_single_accessor(name, options); end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/immutable/common_accessor.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/immutable/base_accessor'
+require 'eac_ruby_utils/patches/class/common_constructor'
+
+module EacRubyUtils
+  module Immutable
+    class CommonAccessor < ::EacRubyUtils::Immutable::BaseAccessor
+      def apply(klass)
+        accessor = self
+        klass.send(:define_method, name) do |*args|
+          case args.count
+          when 0 then next accessor.immutable_value_get(self)
+          when 1 then next accessor.immutable_value_set(self, args.first)
+          else
+            raise ::ArgumentError, "wrong number of arguments (given #{args.count}, expected 0..1)"
+          end
+        end
+      end
+
+      def immutable_value_get(object)
+        object.send(:immutable_values_get)[name]
+      end
+
+      def immutable_value_set(object, value)
+        duplicate_object(object) { |_old_value| value }
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/immutable/hash_accessor.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/immutable/base_accessor'
+require 'eac_ruby_utils/patches/class/common_constructor'
+
+module EacRubyUtils
+  module Immutable
+    class HashAccessor < ::EacRubyUtils::Immutable::BaseAccessor
+      def apply(klass)
+        apply_get(klass)
+        apply_set(klass)
+      end
+
+      def immutable_value_get(object)
+        super || {}
+      end
+
+      def immutable_value_set(object, key, value)
+        duplicate_object(object) do |old_value|
+          (old_value || {}).merge(key => value)
+        end
+      end
+
+      private
+
+      def apply_get(klass)
+        accessor = self
+        klass.send(:define_method, ::ActiveSupport::Inflector.pluralize(name)) do
+          accessor.immutable_value_get(self)
+        end
+      end
+
+      def apply_set(klass)
+        accessor = self
+        klass.send(:define_method, name) do |*args|
+          case args.count
+          when 1 then next accessor.immutable_value_get(self, args[0])
+          when 2 then next accessor.immutable_value_set(self, *args[0..1])
+          else
+            raise ::ArgumentError, "wrong number of arguments (given #{args.count}, expected 1..2)"
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/immutable/instance_methods.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Immutable
+    module InstanceMethods
+      def immutable_constructor_args
+        []
+      end
+
+      private
+
+      def immutable_values_get
+        @immutable_values || {}
+      end
+
+      def immutable_values_set(new_values)
+        @immutable_values = new_values
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/immutable.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/common_concern'
+require 'eac_ruby_utils/require_sub'
+
+module EacRubyUtils
+  module Immutable
+    ::EacRubyUtils.require_sub __FILE__
+
+    common_concern do
+      include ::EacRubyUtils::Listable
+      lists.add_symbol :type, :array, :boolean, :common, :hash
+    end
+  end
+end