avm-tools 0.99.0 → 0.99.1

data/lib/{eac_launcher → avm/launcher}/instances.rb

@@ -3,4 +3,4 @@
 require 'avm/launcher/errors/base'
 require 'avm/launcher/instances/base'
 require 'avm/launcher/instances/runner_helper'
-require 'eac_launcher/instances/settings'
+require 'avm/launcher/instances/settings'

data/lib/avm/launcher/instances/base.rb

@@ -69,7 +69,7 @@ module Avm
         end
 
         def included?
-          !::EacLauncher::Context.current.settings.excluded_projects.include?(project_name)
+          !::Avm::Launcher::Context.current.settings.excluded_projects.include?(project_name)
         end
 
         def to_h
@@ -82,12 +82,12 @@ module Avm
           return false unless stereotype.publish_class
           return false unless options.stereotype_publishable?(stereotype)
 
-          filter = ::EacLauncher::Context.current.publish_options[:stereotype]
+          filter = ::Avm::Launcher::Context.current.publish_options[:stereotype]
           filter.blank? ? true : filter == stereotype.name.demodulize
         end
 
         def options_uncached
-          ::EacLauncher::Context.current.settings.instance_settings(self)
+          ::Avm::Launcher::Context.current.settings.instance_settings(self)
         end
       end
     end

data/lib/avm/launcher/instances/base/cache.rb

@@ -34,7 +34,7 @@ module Avm
           end
 
           def cache_root
-            File.join(::EacLauncher::Context.current.cache_root, name.parameterize)
+            File.join(::Avm::Launcher::Context.current.cache_root, name.parameterize)
           end
         end
       end

data/lib/avm/launcher/instances/runner_helper.rb

@@ -7,7 +7,7 @@ module Avm
     module Instances
       class RunnerHelper
         def context
-          @context ||= ::EacLauncher::Context.current
+          @context ||= ::Avm::Launcher::Context.current
         end
 
         def find_instances(instance_name)

data/lib/avm/launcher/paths.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/paths/logical'
+require 'avm/launcher/paths/real'

data/lib/avm/launcher/paths/logical.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'avm/projects/stereotypes'
+require 'avm/launcher/paths/real'
+
+module Avm
+  module Launcher
+    module Paths
+      class Logical
+        include ::EacRubyUtils::SimpleCache
+
+        class << self
+          def from_h(context, hash)
+            parent_path = hash[:parent_path] ? from_h(context, hash[:parent_path]) : nil
+            new(context, parent_path, hash[:real], hash[:logical])
+          end
+        end
+
+        attr_reader :context, :real, :logical, :parent_path
+
+        def initialize(context, parent_path, real, logical)
+          @context = context
+          @parent_path = parent_path
+          @real = ::Avm::Launcher::Paths::Real.new(real)
+          @logical = logical
+        end
+
+        def to_s
+          logical
+        end
+
+        def to_h
+          { logical: logical, real: real.to_s, parent_path: parent_path ? parent_path.to_h : nil }
+        end
+
+        def project?
+          stereotypes.any?
+        end
+
+        def children
+          r = []
+          Dir.entries(warped).each do |c|
+            c_path = ::File.join(warped, c)
+            next unless ::File.directory?(c_path)
+            next if c.start_with?('.')
+
+            r << build_child(c)
+          end
+          r
+        end
+
+        def included?
+          !context.settings.excluded_paths.include?(logical)
+        end
+
+        private
+
+        def stereotypes_uncached
+          ::Avm::Projects::Stereotype.stereotypes.select { |s| s.match?(self) }
+        end
+
+        def build_child(name)
+          ::Avm::Launcher::Paths::Logical.new(
+            context,
+            self,
+            ::File.join(warped, name),
+            ::File.join(logical, name)
+          )
+        end
+
+        def warped_uncached
+          if is_a?(::Avm::Launcher::Instances::Base)
+            stereotypes.each do |s|
+              return s.warp_class.new(self) if s.warp_class
+            end
+          end
+          real
+        end
+      end
+    end
+  end
+end

data/lib/avm/launcher/paths/real.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Avm
+  module Launcher
+    module Paths
+      class Real < String
+        def initialize(path)
+          raise "Argument path is not a string: \"#{path}\"|#{path.class}" unless path.is_a?(String)
+
+          super(path)
+        end
+
+        def subpath(relative_path)
+          ::Avm::Launcher::Paths::Real.new(::File.expand_path(relative_path, self))
+        end
+
+        def basename
+          ::File.basename(self)
+        end
+
+        def dirname
+          return nil if self == '/'
+
+          self.class.new(::File.dirname(self))
+        end
+
+        def find_file_with_extension(extension)
+          r = find_files_with_extension(extension)
+          return r.first if r.any?
+
+          raise "Extension \"#{extension}\" not found in directory \"#{self}\""
+        end
+
+        def find_files_with_extension(extension)
+          r = []
+          ::Dir.entries(self).each do |i|
+            r << ::File.expand_path(i, self) if i =~ /#{::Regexp.quote(extension)}\z/
+          end
+          r
+        end
+      end
+    end
+  end
+end

data/lib/avm/launcher/project.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Avm
+  module Launcher
+    class Project
+      attr_reader :name, :instances
+
+      def initialize(name, instances)
+        @name = name
+        @instances = instances.to_a
+      end
+
+      def to_s
+        name
+      end
+    end
+  end
+end

data/lib/avm/launcher/publish.rb

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

data/lib/avm/launcher/publish/base.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/errors/base'
+
+module Avm
+  module Launcher
+    module Publish
+      class Base
+        attr_reader :instance
+
+        def initialize(instance)
+          @instance = instance
+        end
+
+        def run
+          s = check
+          info("Check: #{s}")
+          return unless s.status == ::Avm::Launcher::Publish::CheckResult::STATUS_PENDING
+
+          publish
+        end
+
+        def check
+          s = check_with_rescue
+          ::Avm::Launcher::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
+          ::Avm::Launcher::Publish::CheckResult.blocked("Error: #{e}")
+        rescue ::Avm::Launcher::Git::Error => e
+          ::Avm::Launcher::Publish::CheckResult.blocked("Git error: #{e}")
+        end
+      end
+    end
+  end
+end

data/lib/avm/launcher/publish/check_result.rb

@@ -0,0 +1,67 @@
+# 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 Avm
+  module Launcher
+    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
+end

data/lib/avm/launcher/ruby.rb

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

data/lib/avm/launcher/ruby/gem.rb

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

data/lib/avm/launcher/ruby/gem/build.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require 'eac_cli/speaker'
+require 'eac_ruby_utils/envs'
+require 'avm/launcher/ruby/gem/specification'
+
+module Avm
+  module Launcher
+    module Ruby
+      module Gem
+        class Build
+          include ::EacCli::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 = ::Avm::Launcher::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 = ::Avm::Launcher::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
+end