avm-tools 0.45.0 → 0.50.0

data/lib/avm/tools/runner/git.rb

@@ -2,7 +2,7 @@
 
 require 'eac_ruby_utils/console/docopt_runner'
 require 'eac_ruby_utils/require_sub'
-require 'avm/patches/eac_launcher_git_base'
+require 'eac_launcher/git/base'
 ::EacRubyUtils.require_sub(__FILE__)
 
 module Avm

data/lib/avm/tools/runner/launcher.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'eac_launcher/runner'
+
+module Avm
+  module Tools
+    class Runner < ::EacRubyUtils::Console::DocoptRunner
+      class Launcher < ::EacLauncher::Runner
+      end
+    end
+  end
+end

data/lib/avm/tools/version.rb

@@ -2,6 +2,6 @@
 
 module Avm
   module Tools
-    VERSION = '0.45.0'
+    VERSION = '0.50.0'
   end
 end

data/lib/eac_launcher.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+GIT_SUBREPO_LIB = ::File.join(::File.dirname(__dir__), 'vendor', 'git-subrepo', 'lib')
+ENV['PATH'] = "#{GIT_SUBREPO_LIB}#{::File::PATH_SEPARATOR}#{ENV['PATH']}"
+
+module EacLauncher
+  require 'eac_launcher/context'
+  require 'eac_launcher/paths'
+  require 'eac_launcher/project'
+  require 'eac_launcher/stereotype'
+  require 'eac_launcher/git'
+  require 'eac_launcher/instances'
+  require 'eac_launcher/publish'
+  require 'eac_launcher/ruby'
+  require 'eac_launcher/stereotypes'
+  require 'eac_launcher/vendor'
+end

data/lib/eac_launcher/context.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/indifferent_access'
+require 'eac_ruby_utils/simple_cache'
+require 'eac_ruby_utils/console/speaker'
+require 'eac_launcher/context/instance_discovery'
+require 'eac_launcher/context/instance_manager'
+require 'eac_launcher/context/settings'
+require 'eac_launcher/paths/logical'
+require 'eac_launcher/project'
+
+module EacLauncher
+  class Context
+    include ::EacRubyUtils::SimpleCache
+    include ::EacRubyUtils::Console::Speaker
+
+    DEFAULT_PROJECTS_ROOT = '.'
+    DEFAULT_SETTINGS_FILE = ::File.join(ENV['HOME'], '.config', 'eac_launcher', 'settings.yml')
+    DEFAULT_CACHE_ROOT = ::File.join(ENV['HOME'], '.cache', 'eac_launcher')
+
+    class << self
+      attr_writer :current
+
+      def current
+        @current ||= default
+      end
+
+      def default
+        @default ||= Context.new
+      end
+    end
+
+    attr_reader :root, :settings, :cache_root
+    attr_accessor :publish_options, :recache, :instance_manager
+
+    def initialize(options = {})
+      @options = options.with_indifferent_access
+      @root = ::EacLauncher::Paths::Logical.new(self, nil, build_option(:projects_root), '/')
+      @settings = ::EacLauncher::Context::Settings.new(build_option(:settings_file))
+      @cache_root = build_option(:cache_root)
+      @publish_options = { new: false, confirm: false, stereotype: nil }
+      @instance_manager = ::EacLauncher::Context::InstanceManager.new(self)
+      @recache = false
+    end
+
+    def instance(name)
+      instances.find { |i| i.name == name }
+    end
+
+    def instances
+      @instance_manager.instances
+    end
+
+    def pending_instances
+      @instance_manager.pending_instances
+    end
+
+    private
+
+    def build_option(key)
+      @options[key] || env_option(key) || default_option(key)
+    end
+
+    def env_option(key)
+      ENV["EAC_LAUNCHER_#{key}".underscore.upcase]
+    end
+
+    def default_option(key)
+      self.class.const_get("DEFAULT_#{key}".underscore.upcase)
+    end
+
+    def projects_uncached
+      r = {}
+      instances.each do |i|
+        r[i.project_name] ||= []
+        r[i.project_name] << i
+      end
+      r.map { |name, instances| ::EacLauncher::Project.new(name, instances) }
+    end
+  end
+end

data/lib/eac_launcher/context/instance_discovery.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'ruby-progressbar'
+require 'eac_launcher/instances/base'
+
+module EacLauncher
+  class Context
+    class InstanceDiscovery
+      attr_reader :instances
+
+      def initialize(context)
+        @context = context
+        @progress = ::ProgressBar.create(title: 'Instance discovery', total: 1)
+        @instances = path_instances(@context.root, nil)
+      ensure
+        @progress&.finish
+      end
+
+      private
+
+      def path_instances(path, parent_instance)
+        update_progress_format(path)
+        on_rescued_path_instances(path) do |r|
+          if path.project?
+            parent_instance = ::EacLauncher::Instances::Base.instanciate(path, parent_instance)
+            r << path
+          end
+          children = path.children
+          update_progress_count(children)
+          r.concat(children.flat_map { |c| path_instances(c, parent_instance) })
+        end
+      end
+
+      def on_rescued_path_instances(path)
+        r = []
+        begin
+          yield(r) if path.included?
+        rescue StandardError => e
+          warn("#{path}: #{e}")
+        end
+        r
+      end
+
+      def update_progress_format(path)
+        @progress.format = "%t (Paths: %c/%C, Current: #{path.logical}) |%B| %a"
+      end
+
+      def update_progress_count(children)
+        @progress.total += children.count
+        @progress.increment
+      end
+    end
+  end
+end

data/lib/eac_launcher/context/instance_manager.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require('yaml')
+
+module EacLauncher
+  class Context
+    class InstanceManager
+      include ::EacRubyUtils::SimpleCache
+
+      def initialize(context)
+        @context = context
+      end
+
+      def publish_state_set(instance, stereotype_name, check_status)
+        data = cached_instances_file_content_uncached
+        data[instance.logical] ||= {}
+        data[instance.logical][:publish_state] ||= {}
+        data[instance.logical][:publish_state][stereotype_name] = check_status
+        write_cache_file(data)
+      end
+
+      def pending_instances
+        instances.select { |instance| pending_instance?(instance) }
+      end
+
+      private
+
+      def instances_uncached
+        (cached_instances || search_instances).select(&:included?)
+      end
+
+      def search_instances
+        cache_instances(::EacLauncher::Context::InstanceDiscovery.new(@context).instances)
+      end
+
+      def cached_instances
+        return nil if @context.recache
+        return nil unless cached_instances_file_content
+
+        CachedInstances.new(cached_instances_file_content).instances
+      end
+
+      def cached_instances_file_content_uncached
+        r = YAML.load_file(cache_file_path)
+        r.is_a?(::Hash) ? r : nil
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def cache_instances(instances)
+        write_cache_file(Hash[instances.map { |i| [i.logical, i.to_h] }])
+        instances
+      end
+
+      def write_cache_file(data)
+        ::File.write(cache_file_path, data.to_yaml)
+      end
+
+      def cache_file_path
+        ::File.join(@context.cache_root, 'instances.yml')
+      end
+
+      def pending_instance?(instance)
+        data = cached_instances_file_content
+        return false unless data[instance.logical]
+        return false unless data[instance.logical][:publish_state].is_a?(Hash)
+
+        data[instance.logical][:publish_state].any? do |_k, v|
+          ::EacLauncher::Publish::CheckResult.pending_status?(v)
+        end
+      end
+
+      class CachedInstances
+        def initialize(content)
+          @content = content
+          @instances = {}
+        end
+
+        def instances
+          @content.keys.map { |k| by_logical_path(k) }
+        end
+
+        def by_logical_path(key)
+          return @instances[key] if @instances.key?(key)
+
+          h = @content[key]
+          parent_instance = h[:parent] ? by_logical_path(h[:parent]) : nil
+          path = ::EacLauncher::Paths::Logical.from_h(@context, h)
+          @instances[key] = ::EacLauncher::Instances::Base.instanciate(path, parent_instance)
+        end
+      end
+    end
+  end
+end

data/lib/eac_launcher/context/settings.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/simple_cache'
+require 'yaml'
+require 'eac_launcher/instances/settings'
+
+module EacLauncher
+  class Context
+    class Settings
+      include ::EacRubyUtils::SimpleCache
+
+      def initialize(file)
+        unless ::File.exist?(file)
+          ::FileUtils.mkdir_p(::File.dirname(file))
+          ::File.write(file, {}.to_yaml)
+        end
+        @data = YAML.load_file(file)
+      end
+
+      def instance_settings(instance)
+        ::EacLauncher::Instances::Settings.new(value(['Instances', instance.name]))
+      end
+
+      private
+
+      def excluded_projects_uncached
+        enum_value(%w[Projects Exclude])
+      end
+
+      def excluded_paths_uncached
+        enum_value(%w[Paths Exclude])
+      end
+
+      def enum_value(path)
+        r = value(path)
+        r.is_a?(Enumerable) ? r : []
+      end
+
+      def value(path)
+        node_value(@data, path)
+      end
+
+      def node_value(data, path)
+        return data if path.empty?
+        return nil unless data.is_a?(Hash)
+
+        node_value(data[path.first], path.drop(1))
+      end
+    end
+  end
+end

data/lib/eac_launcher/git.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'eac_launcher/git/base'
+require 'eac_launcher/git/error'
+require 'eac_launcher/git/mirror_update'
+require 'eac_launcher/git/publish_base'
+require 'eac_launcher/git/warp_base'

data/lib/eac_launcher/git/base.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/envs'
+require 'eac_launcher/paths/real'
+require 'eac_launcher/git/error'
+
+module EacLauncher
+  module Git
+    class Base < ::EacLauncher::Paths::Real
+      require_sub __FILE__
+      enable_simple_cache
+      extend ::EacLauncher::Git::Base::ClassMethods
+      include ::EacLauncher::Git::Base::DirtyFiles
+      include ::EacLauncher::Git::Base::Remotes
+      include ::EacLauncher::Git::Base::Subrepo
+      include ::EacLauncher::Git::Base::Underlying
+
+      def init_bare
+        FileUtils.mkdir_p(self)
+        ::EacRubyUtils::Envs.local.command('git', 'init', '--bare', self).execute! unless
+        File.exist?(subpath('.git'))
+      end
+
+      def rev_parse(ref, required = false)
+        r = execute!('rev-parse', ref, exit_outputs: { 128 => nil, 32_768 => nil })
+        r.strip! if r.is_a?(String)
+        return r if r.present?
+        return nil unless required
+
+        raise "Reference \"#{ref}\" not found"
+      end
+
+      # @return [Pathname]
+      def root_path
+        @root_path ||= self.class.find_root(to_s)
+      end
+
+      def descendant?(descendant, ancestor)
+        base = merge_base(descendant, ancestor)
+        return false if base.blank?
+
+        revparse = execute!('rev-parse', '--verify', ancestor).strip
+        base == revparse
+      end
+
+      def merge_base(*commits)
+        refs = commits.dup
+        while refs.count > 1
+          refs[1] = merge_base_pair(refs[0], refs[1])
+          return nil if refs[1].blank?
+
+          refs.shift
+        end
+        refs.first
+      end
+
+      def subtree_split(prefix)
+        execute!('subtree', '-q', 'split', '-P', prefix).strip
+      end
+
+      def push(remote_name, refspecs, options = {})
+        refspecs = [refspecs] unless refspecs.is_a?(Array)
+        args = ['push']
+        args << '--dry-run' if options[:dryrun]
+        args << '--force' if options[:force]
+        system!(args + [remote_name] + refspecs)
+      end
+
+      def push_all(remote_name)
+        system!('push', '--all', remote_name)
+        system!('push', '--tags', remote_name)
+      end
+
+      def fetch(remote_name, options = {})
+        args = ['fetch', '-p', remote_name]
+        args += %w[--tags --prune-tags --force] if options[:tags]
+        execute!(*args)
+      end
+
+      def current_branch
+        execute!(%w[symbolic-ref -q HEAD]).gsub(%r{\Arefs/heads/}, '').strip
+      end
+
+      def reset_hard(ref)
+        execute!('reset', '--hard', ref)
+      end
+
+      def raise(message)
+        ::Kernel.raise EacLauncher::Git::Error.new(self, message)
+      end
+
+      private
+
+      def merge_base_pair(commit1, commit2)
+        execute!('merge-base', commit1, commit2, exit_outputs: { 256 => '' }).strip
+      end
+    end
+  end
+end

data/lib/eac_launcher/git/base/class_methods.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module EacLauncher
+  module Git
+    class Base < ::EacLauncher::Paths::Real
+      module ClassMethods
+        # @return [EacLauncher::Git::Base]
+        def by_root(search_base_path)
+          new(find_root(search_base_path).to_path)
+        end
+
+        # Searches the root path for the Git repository which includes +search_base_path+.
+        # @return [Pathname]
+        def find_root(search_base_path)
+          path = search_base_path.to_pathname.expand_path
+          loop do
+            return path if path.join('.git').exist?
+            raise "\".git\" not found for \"#{search_base_path}\"" if path.parent.root?
+
+            path = path.parent
+          end
+        end
+      end
+    end
+  end
+end