avm-tools 0.59.0 → 0.62.2

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative 'base/cache'
+require 'avm/launcher/errors/non_project'
+
+module Avm
+  module Launcher
+    module Instances
+      module Base
+        class << self
+          def extend_object(object)
+            object.extend ::EacRubyUtils::SimpleCache
+            object.extend ::EacRubyUtils::Console::Speaker
+            object.extend ::Avm::Launcher::Instances::Base::Cache
+            super
+          end
+
+          def instanciate(path, parent)
+            unless path.is_a?(::Avm::Launcher::Instances::Base)
+              raise ::Avm::Launcher::Errors::NonProject, path unless path.project?
+
+              path.extend(::Avm::Launcher::Instances::Base)
+              path.parent = parent
+            end
+            path
+          end
+        end
+
+        attr_accessor :parent
+
+        def name
+          logical
+        end
+
+        def stereotype?(stereotype)
+          stereotypes.include?(stereotype)
+        end
+
+        def to_parent_path
+          return self unless @parent
+
+          logical.gsub(/\A#{Regexp.quote(@parent.logical)}/, '')
+        end
+
+        def project?
+          stereotypes.any?
+        end
+
+        def publish_run
+          stereotypes.each do |s|
+            next unless publish?(s)
+
+            infov(name, "publishing #{s.label}")
+            s.publish_class.new(self).run
+          end
+        end
+
+        def publish_check
+          stereotypes.each do |s|
+            next unless publish?(s)
+
+            puts "#{name.to_s.cyan}|#{s.label}|" \
+              "#{s.publish_class.new(self).check}"
+          end
+        end
+
+        def project_name
+          ::File.basename(logical)
+        end
+
+        def included?
+          !::EacLauncher::Context.current.settings.excluded_projects.include?(project_name)
+        end
+
+        def to_h
+          super.to_h.merge(parent: parent ? parent.logical : nil)
+        end
+
+        private
+
+        def publish?(stereotype)
+          return false unless stereotype.publish_class
+
+          filter = ::EacLauncher::Context.current.publish_options[:stereotype]
+          filter.blank? ? true : filter == stereotype.name.demodulize
+        end
+
+        def options_uncached
+          ::EacLauncher::Context.current.settings.instance_settings(self)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Avm
+  module Launcher
+    module Instances
+      module Base
+        module Cache
+          def cache_path(subpath)
+            File.join(cache_root, subpath)
+          end
+
+          def cache_key(key, &block)
+            v = cache_key_get(key)
+            return v if v.present? || block.nil?
+
+            v = yield
+            cache_key_write(key, v)
+            v
+          end
+
+          private
+
+          def cache_key_get(key)
+            File.file?(cache_key_path(key)) ? File.read(cache_key_path(key)) : nil
+          end
+
+          def cache_key_write(key, value)
+            FileUtils.mkdir_p(File.dirname(cache_key_path(key)))
+            File.write(cache_key_path(key), value)
+          end
+
+          def cache_key_path(key)
+            File.join(cache_root, 'keys', key.parameterize)
+          end
+
+          def cache_root
+            File.join(::EacLauncher::Context.current.cache_root, name.parameterize)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/local_projects/instance.rb

@@ -5,11 +5,12 @@ require 'eac_ruby_utils/core_ext'
 require 'avm/projects/stereotypes'
 
 module Avm
-  module LocalProject
+  module LocalProjects
     class Instance
       enable_simple_cache
       common_constructor :path do
         self.path = path.to_pathname
+        source_stereotypes_mixins
       end
 
       # Backward compatibility with [EacLauncher::Paths::Logical].
@@ -23,6 +24,12 @@ module Avm
       def stereotypes_uncached
         ::Avm::Projects::Stereotypes.list.select { |s| s.match?(self) }
       end
+
+      def source_stereotypes_mixins
+        stereotypes.each do |s|
+          s.local_project_mixin_module.if_present { |v| extend(v) }
+        end
+      end
     end
   end
 end

data/lib/avm/local_projects/jobs/update.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module LocalProjects
+    module Jobs
+      class Update
+        enable_console_speaker
+        common_constructor :instance
+
+        def run
+          instance.stereotypes.each { |stereotype| run_stereotype(stereotype) }
+        end
+
+        private
+
+        def run_stereotype(stereotype)
+          if stereotype.update_class.present?
+            puts stereotype.label + ': update class found. Running...'
+            stereotype.update_class.new(instance).run
+          else
+            puts stereotype.label + ': update class not found'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/projects/stereotype.rb

@@ -30,22 +30,29 @@ module Avm
         end
 
         def stereotype_name
-          name.gsub(/^.*::/, '')
+          name.demodulize
         end
 
-        def publish_class
-          sub_class('Publish')
-        end
-
-        def warp_class
-          sub_class('Warp')
+        {
+          local_project_mixin: ::Module,
+          publish: ::Class,
+          update: ::Class,
+          warp: ::Class
+        }.each do |name, is_a|
+          define_method "#{name}_#{is_a.name.underscore}" do
+            sub_constant(name.to_s.camelcase, is_a)
+          end
         end
 
         private
 
-        def sub_class(sub_class_name)
-          klass = const_get(sub_class_name)
-          klass.is_a?(Class) ? klass : nil
+        def sub_constant(constant_name, is_a)
+          constant = const_get(constant_name)
+          unless is_a.if_present(true) { |v| constant.is_a?(v) }
+            raise("#{constant} is not a #{is_a}")
+          end
+
+          constant
         rescue NameError
           nil
         end

data/lib/avm/projects/stereotypes/git/local_project_mixin.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'eac_git/local'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Projects
+    module Stereotypes
+      class Git
+        module LocalProjectMixin
+          # @return [EacGit::Local]
+          def git_repo
+            @git_repo ||= ::EacGit::Local.new(path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/projects/stereotypes/git_subrepo/warp.rb

@@ -2,7 +2,7 @@
 
 require 'eac_ruby_utils/simple_cache'
 require 'eac_launcher/git/sub_warp_base'
-require 'eac_launcher/instances/error'
+require 'avm/launcher/errors/base'
 require 'eac_launcher/paths/real'
 require 'eac_launcher/vendor/github'
 
@@ -32,8 +32,9 @@ module Avm
             return if parent_git_warped.rev_parse(subrepo_parent_hash) &&
                       parent_git_warped.descendant?('HEAD', subrepo_parent_hash)
 
-            raise EacLauncher::Instances::Error, "Subrepo parent hash \"#{subrepo_parent_hash}\""\
-              " not found in \"#{parent_git_warped}\""
+            raise EacLauncher::Instances::Errors::Base,
+                  "Subrepo parent hash \"#{subrepo_parent_hash}\"" \
+                  " not found in \"#{parent_git_warped}\""
           end
 
           def subrepo_parent_hash
@@ -41,7 +42,7 @@ module Avm
             h = data['Pull Parent']
             return h if h.present?
 
-            raise EacLauncher::Instances::Error, "Subrepo parent hash is blank: #{data}"
+            raise EacLauncher::Instances::Errors::Base, "Subrepo parent hash is blank: #{data}"
           end
 
           def init_aux

data/lib/avm/projects/stereotypes/ruby_gem/local_project_mixin.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_gems_utils/gem'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Projects
+    module Stereotypes
+      class RubyGem
+        module LocalProjectMixin
+          # @return [EacRubyGemsUtils::Gem]
+          def ruby_gem
+            @ruby_gem ||= ::EacRubyGemsUtils::Gem.new(path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/projects/stereotypes/ruby_gem/update.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Projects
+    module Stereotypes
+      class RubyGem
+        class Update
+          enable_console_speaker
+          common_constructor :instance
+
+          def run
+            gemfile_lock_checkout
+            bundle_update
+            gemfile_lock_commit
+          end
+
+          private
+
+          def bundle_update
+            infom 'Running "bundle update"...'
+            instance.ruby_gem.bundle('update').execute!
+            infom 'Running "bundle install"...'
+            instance.ruby_gem.bundle('install').execute!
+          end
+
+          def gemfile_lock_checkout
+            return unless instance.respond_to?(:git_repo)
+
+            infom 'Checkouting Gemfile.lock...'
+            instance.git_repo.command('checkout', '--',
+                                      instance.ruby_gem.gemfile_lock_path.to_path).execute!
+          end
+
+          def gemfile_lock_commit
+            return unless instance.respond_to?(:git_repo)
+
+            if gemfile_lock_changed?
+              infom 'Commiting Gemfile.lock...'
+              instance.git_repo.command('commit', '-m', gemfile_lock_commit_message, '--',
+                                        instance.ruby_gem.gemfile_lock_path).execute!
+            else
+              infom 'Gemfile.lock did not change'
+            end
+          end
+
+          def gemfile_lock_commit_message
+            'Todas as gems: atualiza.'
+          end
+
+          def gemfile_lock_changed?
+            instance.git_repo.dirty_file?(instance.ruby_gem.gemfile_lock_path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/stereotypes/eac_webapp_base0/runner/deploy.rb

@@ -32,7 +32,9 @@ module Avm
           end
 
           def stereotype_module
-            "Avm::Stereotypes::#{stereotype_name}".constantize
+            ::Avm::Stereotypes.const_get(stereotype_name)
+          rescue ::NameError
+            ::Avm.const_get(stereotype_name)
           end
 
           def stereotype_name

data/lib/avm/sync.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  class Sync
+    attr_reader :excludes, :includes
+
+    common_constructor :source_path, :target_path do
+      self.source_path = source_path.to_pathname
+      self.target_path = target_path.to_pathname
+      @excludes = []
+      @includes = []
+    end
+
+    def run
+      clear_target
+      copy
+    end
+
+    def add_exclude(exclude)
+      excludes << exclude
+
+      self
+    end
+
+    def add_excludes(*excludes)
+      excludes.each { |exclude| add_exclude(exclude) }
+
+      self
+    end
+
+    def add_include(include)
+      includes << include
+
+      self
+    end
+
+    def add_includes(*includes)
+      includes.each { |include| add_include(include) }
+
+      self
+    end
+
+    def move_mode(value)
+      @move_mode = value
+
+      self
+    end
+
+    def move_mode?
+      @move_mode ? true : false
+    end
+
+    private
+
+    def clear_target
+      target_remove(target_path)
+      target_path.children.each { |tchild| target_remove(tchild) }
+    end
+
+    def copy
+      source_path.children.each do |schild|
+        ::FileUtils.cp_r(schild.to_path, target_path.to_path)
+        schild.rmtree if move_mode?
+      end
+    end
+
+    def source_to_target_path(source_path)
+      source_path.relative_path_from(self.source_path).expand_path(target_path)
+    end
+
+    def target_remove(tpath)
+      return if skip_target_path?(tpath)
+
+      if tpath.directory?
+        tpath.children.each { |tchild| target_remove(tchild) }
+        tpath.rmdir if tpath.children.empty?
+      elsif tpath.file?
+        tpath.unlink
+      end
+    end
+
+    def skip_target_path?(tpath)
+      skip_path?(tpath.relative_path_from(target_path))
+    end
+
+    def skip_path?(relpath)
+      relpath = relpath.expand_path('/')
+      excludes.any? { |exclude| relpath.fnmatch?(exclude) } &&
+        includes.none? { |include| relpath.fnmatch?(include) }
+    end
+  end
+end