avm-tools 0.95.0 → 0.99.1

data/lib/eac_launcher/publish.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_launcher/publish/base'
-require 'eac_launcher/publish/check_result'

data/lib/eac_launcher/publish/base.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'avm/launcher/errors/base'
-
-module EacLauncher
-  module Publish
-    class Base
-      attr_reader :instance
-
-      def initialize(instance)
-        @instance = instance
-      end
-
-      def run
-        s = check
-        info("Check: #{s}")
-        return unless s.status == ::EacLauncher::Publish::CheckResult::STATUS_PENDING
-
-        publish
-      end
-
-      def check
-        s = check_with_rescue
-        ::EacLauncher::Context.current.instance_manager.publish_state_set(
-          instance, stereotype.stereotype_name, s.status
-        )
-        s
-      end
-
-      private
-
-      def stereotype
-        self.class.name.deconstantize.constantize
-      end
-
-      def check_with_rescue
-        internal_check
-      rescue ::Avm::Launcher::Errors::Base => e
-        ::EacLauncher::Publish::CheckResult.blocked("Error: #{e}")
-      rescue ::EacLauncher::Git::Error => e
-        ::EacLauncher::Publish::CheckResult.blocked("Git error: #{e}")
-      end
-    end
-  end
-end

data/lib/eac_launcher/publish/check_result.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern' # Missing on "eac/listable"
-require 'active_support/hash_with_indifferent_access'
-require 'eac_ruby_utils/listable'
-
-module EacLauncher
-  module Publish
-    class CheckResult
-      include ::EacRubyUtils::Listable
-
-      lists.add_string :status, :updated, :pending, :blocked, :outdated
-
-      lists.status.values.each do |status| # rubocop:disable Style/HashEachMethods
-        class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-          def self.#{status}(message)
-            new('#{status}', message)
-          end
-        RUBY_EVAL
-      end
-
-      class << self
-        def pending_status?(status)
-          [STATUS_PENDING].include?(status)
-        end
-
-        def updated_color
-          'green'
-        end
-
-        def pending_color
-          'yellow'
-        end
-
-        def blocked_color
-          'red'
-        end
-
-        def outdated_color
-          'light_blue'
-        end
-      end
-
-      attr_reader :status, :message
-
-      def initialize(status, message)
-        raise "Status \"#{status}\" not in #{self.class.lists.status.values}" unless
-        self.class.lists.status.values.include?(status)
-
-        @status = status
-        @message = message
-      end
-
-      def to_s
-        message.light_white.send("on_#{background_color}")
-      end
-
-      private
-
-      def background_color
-        self.class.send("#{status}_color")
-      end
-    end
-  end
-end

data/lib/eac_launcher/ruby.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_launcher/ruby/gem'

data/lib/eac_launcher/ruby/gem.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_launcher/ruby/gem/build'
-require 'eac_launcher/ruby/gem/specification'

data/lib/eac_launcher/ruby/gem/build.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-require 'tmpdir'
-require 'eac_ruby_utils/console/speaker'
-require 'eac_ruby_utils/envs'
-require 'eac_launcher/ruby/gem/specification'
-
-module EacLauncher
-  module Ruby
-    module Gem
-      class Build
-        include ::EacRubyUtils::Console::Speaker
-
-        def initialize(original_gem_root)
-          @original_gem_root = original_gem_root
-        end
-
-        def output_file
-          return nil unless @gem_root
-
-          @gem_root.find_files_with_extension('.gem').first
-        end
-
-        def builded?
-          output_file.present? && ::File.exist?(output_file)
-        end
-
-        def build
-          return if builded?
-
-          copy_gem_files
-          build_gem
-          check_gem_empty_size
-          check_gem_version
-        end
-
-        def close
-          ::FileUtils.remove_entry(@gem_root) if @gem_root && ::File.directory?(@gem_root)
-          @gem_root = nil
-        end
-
-        private
-
-        def copy_gem_files
-          @gem_root = ::EacLauncher::Paths::Real.new(::Dir.mktmpdir)
-          FileUtils.cp_r "#{@original_gem_root}/.", @gem_root
-        end
-
-        def build_gem
-          info("Building gemspec #{gemspec_file}...")
-          clear_gems
-          Dir.chdir @gem_root do
-            isolated_build_gem
-          end
-        end
-
-        def isolated_build_gem
-          on_clean_ruby do
-            EacRubyUtils::Envs.local.command('gem', 'build', gemspec_file).execute!
-          end
-        end
-
-        def check_gem_empty_size
-          Dir.mktmpdir do |dir|
-            Dir.chdir dir do
-              EacRubyUtils::Envs.local.command('gem', 'unpack', gem).system
-              gs = File.join(dir, File.basename(gem, '.gem'))
-              if (Dir.entries(gs) - %w[. ..]).empty?
-                raise "\"#{dir}\" (Unpacked from #{gem}) has no source code"
-              end
-            end
-          end
-        end
-
-        def clear_gems
-          @gem_root.find_files_with_extension('.gem').each do |f|
-            FileUtils.rm_rf(f)
-          end
-        end
-
-        def gemspec_file
-          @gem_root.find_file_with_extension('.gemspec')
-        end
-
-        def gem
-          @gem_root.find_file_with_extension('.gem')
-        end
-
-        def check_gem_version
-          spec = ::EacLauncher::Ruby::Gem::Specification.new(gemspec_file)
-          return if ::File.basename(output_file, '.gem') == spec.full_name
-
-          raise("Builded gem is not the same version of gemspec (#{spec}, #{output_file})")
-        end
-
-        def bundle_dependencies
-          gemfile = @gem_root.subpath('Gemfile')
-          return unless ::File.exist?(gemfile)
-
-          Dir.chdir(@gem_root) do
-            EacRubyUtils::Envs.local.command('bundle', 'install').execute!
-          end
-        end
-
-        def on_clean_ruby
-          on_clear_envvars('BUNDLE', 'RUBY') { yield }
-        end
-
-        def on_clear_envvars(*start_with_vars)
-          old_values = envvars_starting_with(start_with_vars)
-          old_values.each_key { |k| ENV.delete(k) }
-          yield
-        ensure
-          old_values&.each { |k, v| ENV[k] = v }
-        end
-
-        def envvars_starting_with(start_with_vars)
-          ENV.select { |k, _v| start_with_vars.any? { |var| k.start_with?(var) } }
-        end
-      end
-    end
-  end
-end

data/lib/eac_launcher/ruby/gem/specification.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/object'
-
-module EacLauncher
-  module Ruby
-    module Gem
-      class Specification
-        class << self
-          def parse_version_file(file)
-            s = ::File.read(file)
-            m = /VERSION\s*=\s*[\'\"]([^\'\"]+)[\'\"]/.match(s)
-            m ? m[1] : nil
-          end
-        end
-
-        attr_reader :gemspec_file
-
-        def initialize(gemspec_file)
-          @gemspec_file = gemspec_file
-        end
-
-        def version
-          v = self.class.parse_version_file(version_file)
-          return v if v.present?
-
-          raise "Version not found on file \"#{version_file}\""
-        end
-
-        def name
-          ::File.basename(gemspec_file).gsub(/\.gemspec\z/, '')
-        end
-
-        def full_name
-          "#{name}-#{version}"
-        end
-
-        def to_s
-          full_name
-        end
-
-        private
-
-        def gem_root
-          ::File.dirname(gemspec_file)
-        end
-
-        def version_file
-          f = ::File.join(gem_root, 'lib', *namespace_parts, 'version.rb')
-          return f if ::File.exist?(f)
-
-          raise "Version file \"#{f}\" does not exist"
-        end
-
-        def namespace_parts
-          name.split('-')
-        end
-      end
-    end
-  end
-end

data/lib/eac_launcher/vendor.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_launcher/vendor/github'

data/lib/eac_launcher/vendor/github.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module EacLauncher
-  module Vendor
-    module Github
-      class << self
-        def to_ssh_url(url)
-          return nil if url.blank?
-
-          url_no_dot_git = url.gsub(/\.git\z/, '')
-
-          m = %r{\Ahttps://github.com/([^/]+)/([^/]+)\z}.match(url_no_dot_git.to_s)
-          m ? "git@github.com:#{m[1]}/#{m[2]}.git" : url
-        end
-      end
-    end
-  end
-end

data/lib/eac_launcher/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module EacLauncher
-  VERSION = '0.8.0'
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/console/configs'
-require 'eac_ruby_utils/console/docopt_runner'
-require 'eac_ruby_utils/console/speaker'

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/configs.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/configs'
-require 'eac_ruby_utils/core_ext'
-
-module EacRubyUtils
-  module Console
-    class Configs
-      require_sub __FILE__
-      enable_console_speaker
-
-      class << self
-        def entry_key_to_envvar_name(entry_key)
-          ::EacRubyUtils::Console::Configs::EntryReader.entry_key_to_envvar_name(entry_key)
-        end
-      end
-
-      attr_reader :configs
-
-      def initialize(configs_key, options = {})
-        options.assert_argument(::Hash, 'options')
-        @configs = ::EacRubyUtils::Configs.new(configs_key, options.merge(autosave: true))
-      end
-
-      def read_password(entry_key, options = {})
-        ::EacRubyUtils::Console::Configs::PasswordEntryReader.new(self, entry_key, options).read
-      end
-
-      def read_entry(entry_key, options = {})
-        ::EacRubyUtils::Console::Configs::EntryReader.new(self, entry_key, options).read
-      end
-
-      def store_passwords?
-        ::EacRubyUtils::Console::Configs::StorePasswordsEntryReader.new(self) == 'yes'
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/configs/entry_reader.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/console/configs/read_entry_options'
-require 'eac_ruby_utils/core_ext'
-
-module EacRubyUtils
-  module Console
-    class Configs
-      class EntryReader
-        enable_console_speaker
-
-        class << self
-          def entry_key_to_envvar_name(entry_key)
-            path = if entry_key.is_a?(::Array)
-                     entry_key
-                   else
-                     ::EacRubyUtils::PathsHash.parse_entry_key(entry_key)
-                   end
-            path.join('_').gsub(/[^a-z0-9_]/i, '').gsub(/\A_+/, '').gsub(/_+\z/, '')
-                .gsub(/_{2,}/, '_').upcase
-          end
-        end
-
-        common_constructor :console_configs, :entry_key, :options do
-          self.options = ::EacRubyUtils::Console::Configs::ReadEntryOptions.new(options)
-        end
-
-        def read
-          %w[envvars storage console].each do |suffix|
-            value = send("read_from_#{suffix}")
-            return value if value.present?
-          end
-          return nil unless options[:required]
-
-          raise "No value found for entry \"#{entry_key}\""
-        end
-
-        def read_from_storage
-          console_configs.configs.read_entry(entry_key)
-        end
-
-        def read_from_envvars
-          return if options[:noenv]
-
-          env_entry_key = self.class.entry_key_to_envvar_name(entry_key)
-          return unless ENV.key?(env_entry_key)
-
-          ENV.fetch(env_entry_key).if_present(::EacRubyUtils::BlankNotBlank.instance)
-        end
-
-        def read_from_console
-          return if options[:noinput]
-
-          options[:before_input].if_present(&:call)
-          entry_value = looped_entry_value_from_input
-          console_configs.configs.write_entry(entry_key, entry_value) if options[:store]
-          entry_value
-        end
-
-        private
-
-        def looped_entry_value_from_input
-          loop do
-            entry_value = entry_value_from_input(entry_key, options)
-            next if entry_value.blank?
-            next if options[:validator] && !options[:validator].call(entry_value)
-
-            return entry_value
-          end
-        end
-
-        def entry_value_from_input(entry_key, options)
-          entry_value = request_input("Value for entry \"#{entry_key}\"",
-                                      options.request_input_options)
-          warn('Entered value is blank') if entry_value.blank?
-          entry_value
-        end
-      end
-    end
-  end
-end