eac_tools 0.1.2 → 0.2.2

data/sub/avm-tools/lib/avm/eac_writings_base0/file_build.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module EacWritingsBase0
+    class FileBuild
+      require_sub __FILE__
+      include ::Avm::EacWritingsBase0::FileBuild::BaseStereotype
+      DEFAULT_STEREOTYPES = [::Avm::EacWritingsBase0::FileBuild::ChapterIndex,
+                             ::Avm::EacWritingsBase0::FileBuild::TexSource].freeze
+
+      class << self
+        def stereotypes
+          DEFAULT_STEREOTYPES
+        end
+      end
+
+      common_constructor :project, :subpath do
+        self.class.stereotypes.each do |stereotype|
+          singleton_class.prepend(stereotype) if stereotype.match?(subpath)
+        end
+      end
+
+      def build_to_dir(build_root_target_dir)
+        create_target_dir(build_root_target_dir)
+        copy(target_path(build_root_target_dir))
+      end
+
+      private
+
+      def create_target_dir(build_root_target_dir)
+        FileUtils.mkdir_p(File.dirname(target_path(build_root_target_dir)))
+      end
+
+      def source_path
+        File.join(project.root, subpath)
+      end
+
+      def target_path(build_root_target_dir)
+        File.join(build_root_target_dir, target_subpath)
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/eac_writings_base0/instance.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'avm/eac_webapp_base0/instance'
+
+module Avm
+  module EacWritingsBase0
+    class Instance < ::Avm::EacWebappBase0::Instance
+      FILES_UNITS = {}.freeze
+    end
+  end
+end

data/sub/avm-tools/lib/avm/eac_writings_base0/project.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module EacWritingsBase0
+    class Project
+      common_constructor :root do
+        self.root = root.to_pathname
+      end
+
+      def chapters
+        chapters_file.read.split("\n").map(&:strip).reject { |c| c == '' }
+      end
+
+      def chapters_file
+        root.join('chapters')
+      end
+
+      def name
+        root.basename.to_s
+      end
+
+      def default_output_dir
+        root.join('dist')
+      end
+
+      def default_output_file
+        root.join("#{name}.pdf")
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/eac_writings_base0/project_build/chapters_content.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Avm
+  module EacWritingsBase0
+    class ProjectBuild
+      class << self
+        def chapter_filename(chapter_name)
+          "chapter_#{chapter_name}"
+        end
+      end
+
+      module ChaptersContent
+        private
+
+        def chapter
+          options[:chapter]
+        end
+
+        def chapter_filename(chapter_name)
+          ::Avm::EacWritingsBase0::ProjectBuild.chapter_filename(chapter_name)
+        end
+
+        def check_chapter
+          return unless chapter
+          return if project.chapters.include?(chapter)
+
+          fatal_error("Chapter not found: \"#{chapter}\" (List: #{project.chapters})")
+        end
+
+        def include_content
+          main_path = source_temp_dir.join('main.tex')
+          main_path.write(main_path.read.gsub(CONTENT_VAR, include_chapters_content))
+        end
+
+        def include_chapters_content
+          r = chapters_content
+          r = "\\maketitle\n\n#{r}" if chapter.blank?
+          r
+        end
+
+        def chapters_content
+          project.chapters.map { |c| "\\include{#{chapter_filename(c)}}" }.join("\n")
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/eac_writings_base0/project_build/copy_files.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'avm/eac_writings_base0/commons'
+require 'avm/eac_writings_base0/file_build'
+
+module Avm
+  module EacWritingsBase0
+    class ProjectBuild
+      module CopyFiles
+        def copy_project_files
+          copy_project_dir('.')
+        end
+
+        def copy_project_obj(subpath)
+          return if File.basename(subpath).start_with?('.')
+
+          if File.directory?(File.join(project.root, subpath))
+            copy_project_dir(subpath)
+          else
+            copy_project_file(subpath)
+          end
+        end
+
+        def copy_project_file(subpath)
+          ::Avm::EacWritingsBase0::FileBuild.new(project, subpath).build_to_dir(source_temp_dir)
+        end
+
+        def copy_project_dir(subpath)
+          Dir.entries(File.join(project.root, subpath)).each do |f|
+            copy_project_obj(File.join(subpath, f))
+          end
+        end
+
+        def copy_commons_files
+          target_dir = source_temp_dir.join('commons')
+          target_dir.mkpath
+          ::Avm::EacWritingsBase0::Commons.instance.template.apply(self, target_dir)
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/eac_writings_base0/project_build.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'avm/executables'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/fs/temp'
+require 'eac_ruby_utils/fs/clearable_directory'
+
+module Avm
+  module EacWritingsBase0
+    class ProjectBuild
+      require_sub __FILE__, include_modules: true
+      enable_speaker
+
+      CONTENT_VAR = '%%%CONTENT%%%'
+
+      common_constructor :project, :options do
+        run
+      end
+
+      private
+
+      attr_reader :source_temp_dir
+
+      def run
+        start_banner
+        check_chapter
+        build
+        success('Done!')
+      end
+
+      def start_banner
+        infov('Chapter', chapter)
+        infov('Output file', output_file)
+      end
+
+      def build
+        on_temp_source_dir do
+          copy_project_files
+          copy_commons_files
+          include_content
+          compile
+          check
+          move_output_to_target
+          open_output
+        end
+      end
+
+      def check
+        return if ::File.size(temp_output_file).positive?
+
+        fatal_error("Zero-size file builded: #{temp_output_file}")
+      end
+
+      def compile
+        compile_command.execute!.each_line do |line|
+          if line.include?('No file')
+            raise 'Command returned without error, but there is at least one "No file" line in' \
+              "log: #{line}"
+          end
+        end
+      end
+
+      def compile_command
+        ::Avm::Executables.latex.command(*compile_command_args).chdir(source_temp_dir)
+      end
+
+      def compile_command_args
+        r = ["-output-director=#{build_dir}", '-output-format=pdf',
+             '-interaction=nonstopmode', '-halt-on-error', '-file-line-error']
+        r << if chapter.present?
+               "\\includeonly{#{chapter_filename(chapter)}}\\input{main.tex}"
+             else
+               './main.tex'
+             end
+        r
+      end
+
+      def move_output_to_target
+        File.rename(temp_output_file, output_file)
+        infov('Size', ::Filesize.from("#{File.size(output_file)} B").pretty)
+      end
+
+      def temp_output_file
+        File.join(build_dir, 'main.pdf')
+      end
+
+      def on_temp_source_dir
+        if options[:source_dir].present?
+          @source_temp_dir = ::EacRubyUtils::Fs::ClearableDirectory.new(options.source_dir).clear
+          yield
+        else
+          ::EacRubyUtils::Fs::Temp.on_directory do |directory|
+            @source_temp_dir = directory
+            yield
+          end
+        end
+      end
+
+      def build_dir
+        r = project.root.join('build')
+        r.mkpath
+        r
+      end
+
+      def output_file
+        (options[:output_file] || project.default_output_file)
+      end
+
+      def open_output
+        return unless options[:open]
+
+        infom("Opening \"#{output_file}\"")
+        ::Avm::Executables.xdg_open.command(output_file).system!
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/eac_writings_base0.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module EacWritingsBase0
+    require_sub __FILE__
+  end
+end

data/sub/avm-tools/lib/avm/launcher/context/instance_collector.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceCollector
+        common_constructor :context
+
+        def add_all
+          instances_set.merge(context.instances)
+          self
+        end
+
+        def add_path(path)
+          instances_set.merge(instances_on_path(path))
+          self
+        end
+
+        def add_pending
+          instances_set.merge(context.pending_instances)
+          self
+        end
+
+        def instances
+          instances_set.sort
+        end
+
+        private
+
+        def instance_match?(instance, instance_name)
+          ::File.fnmatch?(instance_name, instance.name)
+        end
+
+        def instances_on_path(path)
+          context.instances.select { |instance| instance_match?(instance, path) }
+        end
+
+        def instances_set
+          @instances_set ||= ::Set.new
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/launcher/context/instance_discovery.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'ruby-progressbar'
+require 'avm/launcher/instances/base'
+
+module Avm
+  module Launcher
+    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 = ::Avm::Launcher::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
+end

data/sub/avm-tools/lib/avm/launcher/context/instance_manager/cached_instance.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/instances/base'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceManager
+        class CachedInstance
+          enable_speaker
+          enable_simple_cache
+          common_constructor :cached_instances, :data
+
+          private
+
+          def instance_uncached
+            ::Avm::Launcher::Instances::Base.instanciate(path, parent_instance)
+          rescue ::Avm::Launcher::Errors::NonProject
+            warn "Cached instance \"#{data[:logical]}\" not found"
+            nil
+          end
+
+          def parent_instance_uncached
+            data[:parent]
+              .if_present { |v| cached_instances.by_logical_path(v) }
+              .if_present(&:instance)
+          end
+
+          def path_uncached
+            ::Avm::Launcher::Paths::Logical.from_h(cached_instances.context, data)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/launcher/context/instance_manager/cached_instances.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/context/instance_manager/cached_instance'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceManager
+        class CachedInstances
+          enable_simple_cache
+          common_constructor :context, :content
+
+          def instances
+            content.keys.map { |k| by_logical_path(k).instance }.reject(&:blank?)
+          end
+
+          def by_logical_path(key)
+            cached_instances[key].if_blank do
+              cached_instances[key] = ::Avm::Launcher::Context::InstanceManager::CachedInstance.new(
+                self, content.fetch(key)
+              )
+            end
+          end
+
+          private
+
+          def cached_instances_uncached
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/launcher/context/instance_manager.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/launcher/publish/check_result'
+require('yaml')
+
+module Avm
+  module Launcher
+    class Context
+      class InstanceManager
+        require_sub __FILE__
+        enable_simple_cache
+        common_constructor :context
+
+        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(::Avm::Launcher::Context::InstanceDiscovery.new(context).instances)
+        end
+
+        def cached_instances
+          return nil if context.recache
+          return nil unless cached_instances_file_content
+
+          CachedInstances.new(self, 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|
+            ::Avm::Launcher::Publish::CheckResult.pending_status?(v)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/launcher/context/settings.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/instances/settings'
+require 'eac_ruby_utils/simple_cache'
+require 'yaml'
+
+module Avm
+  module Launcher
+    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)
+          ::Avm::Launcher::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
+end