rvgp 0.3.2

data/lib/rvgp/application/status_output.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'i18n'
+require 'pastel'
+require 'tty-screen'
+
+module RVGP
+  class Application
+    # These methods output 'pretty' indications of the build process, and is used
+    # by both the rvgp standalone bin, as well as the rake processes themselves.
+    # This class manages colors, icons, indentation and thread syncronization
+    # concerns, relating to status display.
+    # NOTE: This class doesn't know if it wants to be a logger or something else... Let's
+    # see where it ends up
+    #
+    # @attr_reader [Integer] tty_cols The width of the terminal, in characters - This number is calculated at the time
+    #                                 of Object instantiation.
+    class StatusOutputRake
+      attr_reader :tty_cols
+
+      # Create a new STDOUT status output logger
+      # @param [Hash] opts what options to configure this registry with
+      # @option opts [Pastel] :pastel A pastel object to use, for formatting output
+      def initialize(opts = {})
+        @semaphore = Mutex.new
+        @pastel = opts[:pastel] || Pastel.new
+
+        @last_header_outputted = nil
+
+        begin
+          @tty_cols = TTY::Screen.width
+        rescue Errno::ENOENT
+          @tty_cols = 0
+        end
+
+        # NOTE: This is the smallest width I bothered testing on. I don't think
+        # we really care to support this code path in general. If you're this
+        # narrow, umm, fix that.
+        @tty_cols = 40 if @tty_cols < 40
+
+        @complete = I18n.t 'status.indicators.complete'
+        @indent = I18n.t 'status.indicators.indent'
+        @fill = I18n.t 'status.indicators.fill'
+        @attention1 = I18n.t 'status.indicators.attention1'
+        @attention2 = I18n.t 'status.indicators.attention2'
+        @truncated = I18n.t 'status.indicators.truncated'
+      end
+
+      # This is the only public interface, at this time, for use in outputting status.
+      # This is the only method that RVGP needs implemented, on a status output object, should
+      # you choose to write your own.
+      # @param [String] cmd The command that's emmitting this status message
+      # @param [String] desc The I18n key, appended to 'status.commands.', that contains the message you wish to output
+      # @yield [void] A block that contains the execution of this message, and which will return an execution status.
+      # @yieldreturn [Hash<Symbol, Array>] A hash, with the keys :errors, and :warnings, each of which contains a list
+      #                                    of errors and warnings that occurred, during the execution of this block.
+      #                                    These will be stylized and output to the user.
+      # @return [void]
+      def info(cmd, desc, &block)
+        icon, header, prefix = *%w[icon header prefix].map do |attr|
+          I18n.t format('status.commands.%<cmd>s.%<attr>s', cmd: cmd.to_s, attr: attr)
+        end
+
+        @semaphore.synchronize do
+          unless @last_header_outputted == cmd
+            puts ["\n", icon, ' ', @pastel.bold(header)].join
+            @last_header_outputted = cmd
+          end
+        end
+
+        ret = block.call || {}
+
+        has_warn = ret.key?(:warnings) && !ret[:warnings].empty?
+        has_fail = ret.key?(:errors) && !ret[:errors].empty?
+
+        status_length = (if has_warn && has_fail
+                           I18n.t 'status.indicators.complete_and', left: @complete, right: @complete
+                         else
+                           @complete
+                         end).length
+
+        status = if has_warn && has_fail
+                   I18n.t 'status.indicators.complete_and',
+                          left: @pastel.yellow(@complete),
+                          right: @pastel.red(@complete)
+                 elsif has_warn
+                   @pastel.yellow(@complete)
+                 elsif has_fail
+                   @pastel.red(@complete)
+                 else
+                   @pastel.green(@complete)
+                 end
+
+        fixed_element_width = ([@indent, prefix, ' ', @indent, ' ', ' '].join.length + status_length)
+
+        available_width = tty_cols - fixed_element_width
+
+        # If the description is gigantic, we need to constrain it. That's our
+        # variable-length column, so to speak:
+        fill = if available_width <= desc.length
+                 # The plus one is due to the compact'd nil below, which, removes a space
+                 # character, that would have otherwise been placed next to the @fill
+                 desc = desc[0...available_width - @truncated.length - 1] + @truncated
+                 ' '
+               elsif (available_width - desc.length) > 1
+                 [' ', @fill * (available_width - desc.length - 2), ' '].join
+               elsif (available_width - desc.length) == 1
+                 ' '
+               else # This should only be zero
+                 ''
+               end
+
+        @semaphore.synchronize do
+          puts [
+            [@indent, @pastel.bold(prefix), ' ', @pastel.blue(desc), fill, status].join,
+            has_warn ? status_tree(:yellow, ret[:warnings]) : nil,
+            has_fail ? status_tree(:red, ret[:errors]) : nil
+          ].compact.flatten.join("\n")
+        end
+
+        ret
+      end
+
+      private
+
+      def status_tree(color, results)
+        results.map do |result|
+          result.each_with_index.map do |messages, depth|
+            (messages.is_a?(String) ? [messages] : messages).map do |msg|
+              [@indent * 2, @indent * depth,
+               depth.positive? ? @pastel.send(color, @attention2) : @pastel.send(color, @attention1),
+               depth.positive? ? msg : @pastel.send(color, msg)].join
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rvgp/application.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require_relative 'application/status_output'
+require_relative 'application/config'
+
+module RVGP
+  # The main application class, by which all projects are defined. This class
+  # contains the methods and properties that are intrinsic to the early stages of
+  # project initialization, and which provides the functionality used by
+  # submodules initialized after initialization. In addition, this class implements
+  # the main() entry point used by Rakefiles, and in turn, instigates the
+  # equivalent entry points in various modules thereafter.
+  #
+  # @attr_reader [String] project_path The directory path, from which this application was initialized.
+  # @attr_reader [RVGP::Application::StatusOutputRake] logger The application logger. This is provided so that callers
+  #                                             can output to the console. (Or wherever the output device is logging)
+  # @attr_reader [RVGP::Journal::Pricer] pricer This attribute contains the pricer that's used by the application. Price
+  #                                            data is automatically loaded from config.prices_path (typically
+  #                                            'journals/prices.db')
+  # @attr_reader [RVGP::Application::Config] config The application configuration, most of which is parsed from the
+  #                                                config.yaml
+  class Application
+    # This error is thrown when the project_path provided to {Application#initialize} doesn't exist, and/or is
+    # otherwise invalid.
+    class InvalidProjectDir < StandardError; end
+
+    attr_reader :project_path, :logger, :pricer, :config
+
+    # Creates an instance of Application, given the files and structure of the provided project path.
+    # @param project_path [String] The path, to an RVGP project directory.
+    def initialize(project_path)
+      raise InvalidProjectDir unless [project_path, format('%s/app', project_path)].all? { |f| Dir.exist? f }
+
+      @project_path = project_path
+      @config = RVGP::Application::Config.new project_path
+      @logger = RVGP::Application::StatusOutputRake.new pastel: RVGP.pastel
+
+      if File.exist? config.prices_path
+        @pricer = RVGP::Journal::Pricer.new(
+          File.read(config.prices_path),
+          # See the documentation in RVGP::Journal::Pricer#initialize, to better understand what's happening here.
+          # And, Note that this functionality is only supported when ledger is the pta adapter.
+          before_price_add: lambda { |time, from_alpha, to|
+            puts [
+              RVGP.pastel.yellow(I18n.t('error.warning')),
+              I18n.t('error.missing_entry_in_prices_db', time: time, from: from_alpha, to: to)
+            ].join ' '
+          }
+        )
+      end
+
+      # Include all the project files:
+      require_commands!
+      require_validations!
+      require_grids!
+    end
+
+    # @return [Array] An array, containing all the reconciler objects, defined in the project
+    def reconcilers
+      @reconcilers ||= RVGP::Base::Reconciler.all project_path
+    end
+
+    # This method will insert all the project tasks, into a Rake object.
+    # Typically, 'self' is that object, when calling from a Rakefile. (aka 'main')
+    # @param rake_main [Object] The Rake object to attach RVGP to.
+    # @return [void]
+    def initialize_rake!(rake_main)
+      require 'rake/clean'
+
+      CLEAN.include FileList[RVGP.app.config.build_path('*')]
+
+      # This removes clobber from the task list:
+      Rake::Task['clobber'].clear_comments
+
+      project_tasks_dir = format('%s/tasks', project_path)
+      Rake.add_rakelib project_tasks_dir if File.directory? project_tasks_dir
+
+      RVGP.commands.each do |command_klass|
+        command_klass.initialize_rake rake_main if command_klass.respond_to? :initialize_rake
+      end
+
+      rake_main.instance_eval do
+        default_tasks = %i[reconcile validate_journal validate_system]
+        multitask reconcile: RVGP.app.reconcilers.map { |tf| "reconcile:#{tf.as_taskname}" }
+        multitask validate_journal: RVGP.app.reconcilers.map { |tf| "validate_journal:#{tf.as_taskname}" }
+        multitask validate_system: RVGP.system_validations.task_names
+
+        # There's a chicken-and-an-egg problem that's due:
+        #  - users (potentially) wanting to see/trigger specific plot and grid targets, in a clean project
+        #  - A pre-requisite that journals (and grids) exist, in order to determine what grid/plot targets
+        #    are available.
+        # So, what we do here, is do our best to determine what's available in a clean build. And, at the
+        # time at which we're ready to start buildings grids/plots - we re-initialize the available tasks
+        # based on what was built prior in the running build.
+        #
+        # Most grids can be determined by examining the reconciler years that exist in the app/ directory.
+        # But, in the case that new year starts, and the prior year hasn't been rotated, we'll be adding
+        # additional grids here.
+        #
+        # As for plots... probably we can do a better job of pre-determining those. But, they're pretty
+        # inconsequential in the build time, so, unless someone needs this feature for some reason, there
+        # are 'no' plots at the time of a full rake build, and the rescan adds them here after the grids
+        # are built.
+
+        isnt_reconciled = RVGP::Commands::Reconcile::Target.all.any? { |t| !t.uptodate? }
+        if isnt_reconciled
+          desc I18n.t('commands.rescan_grids.target_description')
+          task :rescan_grids do |_task, _task_args|
+            RVGP::Commands::Grid.initialize_rake rake_main
+            multitask grid: RVGP.grids.task_names
+          end
+          default_tasks << :rescan_grids
+        end
+
+        default_tasks << :grid
+        multitask grid: RVGP.grids.task_names
+
+        if isnt_reconciled || RVGP::Commands::Grid::Target.all.any? { |t| !t.uptodate? }
+          # This re-registers the grid tasks, into the rake
+          desc I18n.t('commands.rescan_plots.target_description')
+          task :rescan_plots do |_task, _task_args|
+            RVGP::Commands::Plot.initialize_rake rake_main
+            multitask plot: RVGP::Commands::Plot::Target.all.map { |t| "plot:#{t.name}" }
+          end
+          default_tasks << :rescan_plots
+        end
+
+        default_tasks << :plot
+        multitask plot: RVGP::Commands::Plot::Target.all.map { |t| "plot:#{t.name}" }
+
+        task default: default_tasks
+      end
+    end
+
+    # This helper method will create the provided subdir inside the project's build/ directory, if that
+    # subdir doesn't already exist. In the case that this subdir already exists, the method terminates
+    # gracefully, without action.
+    # @return [void]
+    def ensure_build_dir!(subdir)
+      path = RVGP.app.config.build_path subdir
+      FileUtils.mkdir_p path unless File.directory? path
+    end
+
+    private
+
+    def require_commands!
+      # Built-in commands:
+      RVGP::Commands.require_files!
+
+      # App commands:
+      require_app_files! 'commands'
+    end
+
+    def require_grids!
+      require_app_files! 'grids'
+    end
+
+    def require_validations!
+      # Built-in validations:
+      Dir.glob(RVGP::Gem.root('lib/rvgp/validations/*.rb')).sort.each { |file| require file }
+
+      # App validations:
+      require_app_files! 'validations'
+    end
+
+    def require_app_files!(subdir)
+      Dir.glob([project_path, 'app', subdir, '*.rb'].join('/')).sort.each { |file| require file }
+    end
+  end
+end