indoctrinatr-tools 0.16.0 → 0.17.0

data/lib/indoctrinatr/tools/transactions/template_pack_demo.rb

@@ -0,0 +1,104 @@
+require 'dry/transaction'
+
+module Indoctrinatr
+  module Tools
+    module Transactions
+      class TemplatePackDemo
+        include Dry::Transaction
+
+        step :scaffold
+        step :parse
+        step :pdf
+        step :pdf_with_field_names
+        step :doc
+        step :pack
+
+        private
+
+        def scaffold(template_pack_name)
+          TemplatePackScaffold.new.call(template_pack_name) do |result|
+            result.success do |message|
+              puts message
+            end
+
+            result.failure do |message|
+              puts message
+              exit 1
+            end
+          end
+          Success(template_pack_name)
+        end
+
+        def parse(template_pack_name)
+          Indoctrinatr::Tools::Transactions::TemplatePackDefaultValuesParser.new.call(template_pack_name) do |result|
+            result.success do |message|
+              puts message
+            end
+
+            result.failure do |message|
+              puts message
+              exit 1
+            end
+          end
+          Success(template_pack_name)
+        end
+
+        def pdf(template_pack_name)
+          TemplatePackDefaultValuesCompiler.new.call(template_pack_name:, keep_aux_files: false) do |result|
+            result.success do |message|
+              puts message
+            end
+
+            result.failure do |message|
+              puts message
+              exit 1
+            end
+          end
+          Success(template_pack_name)
+        end
+
+        def pdf_with_field_names(template_pack_name)
+          TemplatePackFieldnamesCreator.new.call(template_pack_name:, keep_aux_files: false) do |result|
+            result.success do |message|
+              puts message
+            end
+
+            result.failure do |message|
+              puts message
+              exit 1
+            end
+          end
+          Success(template_pack_name)
+        end
+
+        def doc(template_pack_name)
+          TemplatePackDocumentation.new.call(template_pack_name:, keep_aux_files: false) do |result|
+            result.success do |message|
+              puts message
+            end
+
+            result.failure do |message|
+              puts message
+              exit 1
+            end
+          end
+          Success(template_pack_name)
+        end
+
+        def pack(template_pack_name)
+          TemplatePackPacker.new.call(template_pack_name) do |result|
+            result.success do |message|
+              puts message
+            end
+
+            result.failure do |message|
+              puts message
+              exit 1
+            end
+          end
+          Success()
+        end
+      end
+    end
+  end
+end

data/lib/indoctrinatr/tools/transactions/template_pack_documentation.rb

@@ -0,0 +1,223 @@
+require 'dry/transaction'
+require 'erubis'
+require 'to_latex'
+require 'fileutils'
+require 'tmpdir'
+
+module Indoctrinatr
+  module Tools
+    module Transactions
+      class TemplatePackDocumentation
+        include PdfGenerator
+        include Dry::Transaction
+
+        step :setup
+        step :fill_documentation_content
+        step :read_content_tex_file
+        step :read_main_tex_file
+        step :parse_content_tex_file
+        step :parse_main_tex_file
+        step :create_temp_compile_dir
+        step :compile_setup
+        step :write_content_tex_file
+        step :write_main_tex_file
+        step :copy_source_files
+        step :compile_documentation_to_pdf
+        step :handle_aux_files
+        step :generate_success_message
+
+        private
+
+        def setup(template_pack_name:, keep_aux_files:)
+          documentation_files_path = Pathname.new(File.expand_path(__dir__)).join('..', '..', 'templates', 'documentation')
+          content_tex_file_path = documentation_files_path.join 'indoctrinatr-technical-documentation-content.tex.erb'
+          source_main_tex_file_path = documentation_files_path.join 'indoctrinatr-technical-documentation.tex.erb'
+          path_name = Pathname.new(Dir.pwd).join template_pack_name
+          pack_documentation_dir_path = path_name.join 'doc'
+          pack_technical_documentation_file_path = pack_documentation_dir_path.join "#{template_pack_name}_technical_documentation.pdf"
+          Success(
+            {
+              content_tex_file_path:,
+              template_pack_name:,
+              documentation_files_path:,
+              keep_aux_files:,
+              source_main_tex_file_path:,
+              pack_documentation_dir_path:,
+              pack_technical_documentation_file_path:,
+              path_name:
+            }
+          )
+        end
+
+        def fill_documentation_content(config)
+          configuration = ConfigurationExtractor.new(config[:template_pack_name]).call
+          documentation_content = TemplateDocumentationContent.new(config[:template_pack_name], configuration)
+          config[:documentation_content] = documentation_content
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def read_content_tex_file(config)
+          content_tex_file_content = File.read(config[:content_tex_file_path], encoding: 'Utf-8')
+          config[:content_tex_file_content] = content_tex_file_content
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def read_main_tex_file(config)
+          main_tex_file_content = File.read(config[:source_main_tex_file_path], encoding: 'Utf-8')
+          config[:main_tex_file_content] = main_tex_file_content
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def parse_content_tex_file(config)
+          parsed_content_tex_file_content = Erubis::Eruby.new(config[:content_tex_file_content]).result(config[:documentation_content].retrieve_binding)
+          config[:parsed_content_tex_file_content] = parsed_content_tex_file_content
+          # TODO: more useful error messages for user on errors
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def parse_main_tex_file(config)
+          parsed_main_tex_file_content = Erubis::Eruby.new(config[:main_tex_file_content]).result(config[:documentation_content].retrieve_binding)
+          config[:parsed_main_tex_file_content] = parsed_main_tex_file_content
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def create_temp_compile_dir(config)
+          documentation_compile_dir_path_name = Pathname.new Dir.mktmpdir 'indoctrinatr_tools_tmp'
+          config[:documentation_compile_dir_path_name] = documentation_compile_dir_path_name
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def compile_setup(config)
+          content_tex_file_destination_path = config[:documentation_compile_dir_path_name].join 'indoctrinatr-technical-documentation-content.tex'
+          config[:content_tex_file_destination_path] = content_tex_file_destination_path
+
+          main_tex_file_destination_path = config[:documentation_compile_dir_path_name].join 'indoctrinatr-technical-documentation.tex'
+          config[:main_tex_file_destination_path] = main_tex_file_destination_path
+
+          source_latex_package_file_path = config[:documentation_files_path].join 'indoctrinatr-technical-documentation.sty'
+          config[:source_latex_package_file_path] = source_latex_package_file_path
+
+          latex_package_destination_path = config[:documentation_compile_dir_path_name].join 'indoctrinatr-technical-documentation.sty'
+          config[:latex_package_destination_path] = latex_package_destination_path
+
+          source_letterpaper_file_path = config[:documentation_files_path].join 'indoctrinatr_letterpaper.pdf'
+          config[:source_letterpaper_file_path] = source_letterpaper_file_path
+
+          letterpaper_file_destination_path = config[:documentation_compile_dir_path_name].join 'indoctrinatr_letterpaper.pdf'
+          config[:letterpaper_file_destination_path] = letterpaper_file_destination_path
+
+          source_image_tools_package_file_path = config[:documentation_files_path].join 'dkd-image-tools.sty'
+          config[:source_image_tools_package_file_path] = source_image_tools_package_file_path
+
+          image_tools_package_destination_path = config[:documentation_compile_dir_path_name].join 'dkd-image-tools.sty'
+          config[:image_tools_package_destination_path] = image_tools_package_destination_path
+
+          latex_log_file = config[:documentation_compile_dir_path_name].join 'indoctrinatr-technical-documentation.log'
+          config[:latex_log_file] = latex_log_file
+
+          latex_log_file_destination = config[:path_name].join "#{config[:template_pack_name]}documentation_latex_failure.log"
+          config[:latex_log_file_destination] = latex_log_file_destination
+
+          documentation_file_path = config[:documentation_compile_dir_path_name].join 'indoctrinatr-technical-documentation.pdf'
+          config[:documentation_file_path] = documentation_file_path
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def write_content_tex_file(config)
+          File.write config[:content_tex_file_destination_path], config[:parsed_content_tex_file_content]
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def write_main_tex_file(config)
+          File.write config[:main_tex_file_destination_path], config[:parsed_main_tex_file_content]
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def copy_source_files(config)
+          ::FileUtils.copy_file config[:source_latex_package_file_path], config[:latex_package_destination_path]
+          ::FileUtils.copy_file config[:source_letterpaper_file_path], config[:letterpaper_file_destination_path]
+          ::FileUtils.copy_file config[:source_image_tools_package_file_path], config[:image_tools_package_destination_path]
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def compile_documentation_to_pdf(config)
+          make_pdf config[:main_tex_file_destination_path], config[:documentation_compile_dir_path_name], cleanup: !config[:keep_aux_files]
+          copy_doc_file_to_template_pack(config)
+
+          if config[:keep_aux_files]
+            copy_helper_files_to_template_pack(config)
+            show_temp_directory(config)
+          end
+          Success(config)
+        rescue StandardError => e
+          handle_latex_error(config)
+          Failure(e.message)
+        end
+
+        def copy_helper_files_to_template_pack(config)
+          helper_files_to_copy = [config[:latex_log_file], config[:content_tex_file_destination_path], config[:main_tex_file_destination_path]].freeze
+          ::FileUtils.mkdir_p(config[:pack_documentation_dir_path])
+          ::FileUtils.copy helper_files_to_copy, config[:pack_documentation_dir_path]
+          puts 'TeX files and log file have been copied to doc subdirectory of your template_pack'
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def copy_doc_file_to_template_pack(config)
+          # All the documentation shall go into template_pack/doc
+          ::FileUtils.mkdir_p(config[:pack_documentation_dir_path])
+          ::FileUtils.copy_file config[:documentation_file_path], config[:pack_technical_documentation_file_path]
+        end
+
+        def handle_aux_files(config)
+          if config[:keep_aux_files]
+            copy_helper_files_to_template_pack(config)
+            show_temp_directory(config)
+          else
+            delete_temp_dir(config)
+          end
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def show_temp_directory(config)
+          puts "Look into the directory #{config[:documentation_compile_dir_path_name]} to see all files related to the technical documentation compilation"
+        end
+
+        def delete_temp_dir(config)
+          ::FileUtils.remove_entry_secure config[:documentation_compile_dir_path_name]
+        end
+
+        def handle_latex_error(config)
+          puts "possible LaTeX compilation failure! see #{config[:latex_log_file_destination]} for details. " # idea: process $CHILD_STATUS
+          ::FileUtils.copy_file config[:latex_log_file], config[:latex_log_file_destination]
+        end
+
+        def generate_success_message(config)
+          Success("A documentation for '#{config[:template_pack_name]}' has been successfully generated.")
+        end
+      end
+    end
+  end
+end

data/lib/indoctrinatr/tools/transactions/template_pack_error_checker.rb

@@ -0,0 +1,127 @@
+require 'dry/transaction'
+require 'yaml'
+
+module Indoctrinatr
+  module Tools
+    module ErrorChecker
+      class TemplatePackErrorChecker
+        include Dry::Transaction
+
+        # class wide constants
+        # needs to match indoctrinatr's TemplateField model
+        VALID_PRESENTATIONS = %w[text textarea checkbox radiobutton dropdown date range file].freeze
+        REQUIRES_AVAILABLE_OPTIONS = %w[dropdown checkbox radiobutton].freeze
+
+        step :setup
+        step :check_config_file_existence
+        step :check_config_file_syntax
+        step :check_attributes
+
+        # TODO: check multiple variable name declaration (low-prio)
+
+        private
+
+        def setup(template_pack_name)
+          path_name = Pathname.new(Dir.pwd).join template_pack_name
+          config_file_path = path_name.join 'configuration.yaml'
+          Success(
+            {
+              template_pack_name:,
+              path_name:,
+              config_file_path:
+            }
+          )
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def check_config_file_existence(config)
+          return Failure('The file configuration.yaml does not exist in the template_pack directory') unless File.exist? config[:config_file_path]
+
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        # YAML syntax check
+        def check_config_file_syntax(config)
+          puts 'Checking YAML syntax...'
+          YAML.parse_file config[:config_file_path]
+          puts 'YAML syntax ok!'
+          Success(config)
+        rescue YAML::SyntaxError => e # no program abort when this exception is thrown
+          puts 'YAML syntax error in configuration.yaml, see error for details:'
+          Failure(e.message)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def check_attributes(config)
+          configuration = ConfigurationExtractor.new(config[:template_pack_name]).call
+          puts 'Checking attributes...'
+
+          configuration.attributes_as_hashes_in_array.each_with_index do |attribute_hash, index|
+            identifier = "Variable number #{index + 1}" # string for the user to localize variable with errors/warnings
+            name_field = check_field_attribute attribute_hash, identifier, 'name'
+            identifier = "Variable \"#{name_field}\"" if name_field != false
+
+            check_presentation attribute_hash, identifier
+
+            check_field_attribute attribute_hash, identifier, 'default_value'
+
+            check_field_attribute attribute_hash, identifier, 'description'
+            # idea: warning if no required attribute?
+          end
+          Success('Checking complete.')
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        # false if something wrong, otherwise returns the key value
+        def check_field_attribute(attribute_hash, field_identifier, key)
+          unless attribute_hash.key? key
+            puts "The #{field_identifier} has no #{key} type set!"
+            return false
+          end
+          if attribute_hash[key].nil? || attribute_hash[key].empty?
+            puts "The #{field_identifier} has an empty #{key}!"
+            false
+          else
+            attribute_hash[key]
+          end
+        end
+
+        def check_presentation(attribute_hash, identifier)
+          presentation = check_field_attribute attribute_hash, identifier, 'presentation'
+          return false unless presentation
+
+          # check if it is one of the options
+          puts "Not an allowed presentation option set for #{identifier}" unless VALID_PRESENTATIONS.include? presentation
+          check_available_options attribute_hash, identifier, presentation if REQUIRES_AVAILABLE_OPTIONS.include? presentation
+          check_presentation_range attribute_hash, identifier, presentation if presentation == 'range'
+        end
+
+        def check_available_options(attribute_hash, identifier, presentation_type)
+          unless attribute_hash.key? 'available_options'
+            puts "The #{identifier} has no available_options (needed for #{presentation_type} presentation)"
+            return false
+          end
+          available_options = attribute_hash['available_options']
+          if available_options.nil?
+            puts("available_options for #{identifier} is empty (needed for #{presentation_type} presentation)")
+            false
+          else
+            puts("available_options for #{identifier} has only one option. That is useless.") if available_options.count(',') == 1
+            true
+          end
+        end
+
+        def check_presentation_range(attribute_hash, identifier, presentation)
+          puts "The #{identifier} has no start_of_range field (needed for #{presentation} presentation)" unless attribute_hash.key? 'start_of_range'
+          puts "The #{identifier} has no end_of_range field (needed for #{presentation} presentation)" unless attribute_hash.key? 'end_of_range'
+          # TODO: check for content
+        end
+      end
+    end
+  end
+end

data/lib/indoctrinatr/tools/transactions/template_pack_fieldnames_creator.rb

@@ -0,0 +1,97 @@
+require 'dry/transaction'
+require 'erubis'
+require 'to_latex'
+require 'fileutils'
+
+module Indoctrinatr
+  module Tools
+    module Transactions
+      class TemplatePackFieldnamesCreator
+        include PdfGenerator
+        include Dry::Transaction
+
+        step :setup
+        step :check_setup
+        step :read_config_file
+        step :read_tex_file
+        step :parse_tex_file
+        step :write_tex_file
+        step :result
+
+        private
+
+        def setup(template_pack_name:, keep_aux_files:)
+          path_name = Pathname.new(Dir.pwd).join template_pack_name
+          pack_documentation_dir_path = path_name.join 'doc'
+          pack_documentation_examples_dir_path = pack_documentation_dir_path.join('examples')
+          tex_with_default_values_file_path = pack_documentation_examples_dir_path.join("#{template_pack_name}_with_default_values.tex")
+          tex_with_fieldname_values_file_path = pack_documentation_examples_dir_path.join("#{template_pack_name}_with_fieldname_values.tex")
+          Success(
+            {
+              template_pack_name:,
+              path_name:,
+              keep_aux_files:,
+              pack_documentation_dir_path:,
+              pack_documentation_examples_dir_path:,
+              tex_with_default_values_file_path:,
+              tex_with_fieldname_values_file_path:
+            }
+          )
+        end
+
+        def check_setup(config)
+          return Failure('Please specify a template pack name.') if config[:template_pack_name].empty?
+          return Failure("A folder with name '#{config[:template_pack_name]}' does not exist.") unless Dir.exist? config[:path_name] # rub
+
+          Success(config)
+        end
+
+        def read_config_file(config)
+          configuration = ConfigurationExtractor.new(config[:template_pack_name]).call
+          field_name_values = FieldNameValues.new configuration
+          field_name_values._field_names_as_values
+          config[:configuration] = configuration
+          config[:field_name_values] = field_name_values
+          Success(config)
+        end
+
+        def read_tex_file(config)
+          tex_file_path = config[:path_name].join("#{config[:template_pack_name]}.tex.erb")
+          config[:tex_file_content] = File.read tex_file_path
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def parse_tex_file(config)
+          config[:parsed_tex_file_content] = Erubis::Eruby.new(config[:tex_file_content]).result(config[:field_name_values].retrieve_binding)
+          puts "The template pack '#{config[:template_pack_name]}' has been successfully parsed with the variable names."
+          puts 'Please check the .tex file and modify it to your needs and compile it again'
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def write_tex_file(config)
+          # Create directory to avoid file creation errors
+          ::FileUtils.mkdir_p(config[:pack_documentation_dir_path])
+          ::FileUtils.mkdir_p(config[:pack_documentation_examples_dir_path])
+          File.write config[:tex_with_fieldname_values_file_path], config[:parsed_tex_file_content]
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def result(config)
+          make_pdf config[:tex_with_fieldname_values_file_path], config[:pack_documentation_examples_dir_path], cleanup: !config[:keep_aux_files]
+        rescue StandardError => e
+          puts 'possible LaTeX compilation failure!' # see #{latex_log_file_destination} for details. " # idea: process $CHILD_STATUS
+          # FileUtils.copy_file latex_log_file, latex_log_file_destination
+          Failure(e.message)
+        else
+          Success('A pdf including variable names has successfully been created.')
+        end
+      end
+    end
+  end
+end

data/lib/indoctrinatr/tools/transactions/template_pack_packer.rb

@@ -0,0 +1,73 @@
+require 'dry/transaction'
+require 'zip'
+require 'fileutils'
+
+module Indoctrinatr
+  module Tools
+    module Transactions
+      class TemplatePackPacker
+        include Dry::Transaction
+
+        step :setup
+        step :validate_setup
+        step :remove_existing_zip
+        step :zip_template_folder
+        step :show_success
+
+        private
+
+        def setup(template_pack_name)
+          Success(
+            {
+              template_pack_name:,
+              path_name: Pathname.new(Dir.pwd).join(template_pack_name)
+            }
+          )
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def validate_setup(config)
+          return Failure('Please specify a template pack name.') if config[:template_pack_name].nil? || config[:template_pack_name].empty?
+          return Failure("A folder with name '#{config[:template_pack_name]}' does not exist.") unless Dir.exist? config[:path_name]
+
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def remove_existing_zip(config)
+          ::FileUtils.rm destination_zip_file(config[:template_pack_name]), force: true
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def zip_template_folder(config)
+          Zip::File.open(destination_zip_file(config[:template_pack_name]), Zip::File::CREATE) do |zipfile|
+            Dir[File.join(config[:path_name], '**', '**')].each do |file|
+              zipfile.add(internal_file_name(file, config[:template_pack_name], config[:path_name]), file)
+            end
+          end
+          Success(config)
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def show_success(config)
+          Success("The template pack '#{config[:template_pack_name]}.zip' was created successfully.")
+        rescue StandardError => e
+          Failure(e.message)
+        end
+
+        def destination_zip_file(template_pack_name)
+          Pathname.new(Dir.pwd).join "#{template_pack_name}.zip"
+        end
+
+        def internal_file_name(file_name, template_pack_name, path_name)
+          "#{template_pack_name}/#{file_name.sub(path_name.to_s, '')[1..]}" # remove leading /
+        end
+      end
+    end
+  end
+end