k_manager 0.0.24 → 0.0.32

data/lib/k_manager/cli/new.rb

@@ -14,45 +14,109 @@ module KManager
                   default: '.builders',
                   desc: 'The builder folder, defaults to (.builders)'
 
-        option    :boot_file,
-                  default: 'boot.rb',
-                  aliases: ['-b'],
-                  desc: 'The name of the boot file to create'
-
         option    :force,
                   default: false,
                   aliases: ['-f'],
                   desc: 'Force even if guard fails'
 
+        option    :template,
+                  default: false,
+                  aliases: ['-t'],
+                  desc: 'Starter template'
+
+        option    :log_level,
+                  default: nil,
+                  desc: 'Log level, use debug for more info'
+
+        option    :description,
+                  default: nil,
+                  aliases: ['-d'],
+                  desc: 'Application description'
+
+        option    :user_story,
+                  default: nil,
+                  desc: 'Main user story'
+
+        option    :repo_organization,
+                  default: nil,
+                  desc: 'Repository organization'
+
         example [
           '                           # Project in current directory - will create a .builders folder and boot file at ./builders/boot.rb',
           '-b ../config/boot.rb       # Project in current directory - will create a .builders folder and boot file at ./config/boot.rb',
+          '-t ruby_gem                # Use starter template `ruby_gem` to setup the files in .builders/*',
           'my_project                 # will watch .xmen folder'
         ]
 
         # rubocop:disable Metrics/ParameterLists
-        def call(project_folder:, builder_folder:, boot_file:, log_level:, force:, **)
-          project_folder  = absolute_path(project_folder, Dir.pwd)
-          name            = File.basename(project_folder)
-          builder_folder  = absolute_path(builder_folder, project_folder)
-          boot_file       = absolute_path(boot_file, builder_folder)
+        def call(project_folder:, builder_folder:, log_level:, force:, template:, **opts)
+          project_folder        = absolute_path(project_folder, Dir.pwd)
+          name                  = File.basename(project_folder)
+          builder_folder        = absolute_path(builder_folder, project_folder)
+          template_root_folder  = File.expand_path('~/dev/kgems/k_templates/definitions/starter')
 
-          log_params(name, project_folder, builder_folder, boot_file, force) if log_level == 'debug'
+          log_params(name, project_folder, builder_folder, force, log_level, template_root_folder, template, **opts) if log_level == 'debug'
 
-          create_project(project_folder, builder_folder, boot_file) if can_create?(force, builder_folder)
+          create_project(name, project_folder, builder_folder, template_root_folder, template, **opts) if can_create?(force, builder_folder)
         end
         # rubocop:enable Metrics/ParameterLists
 
         private
 
-        def create_project(project_folder, builder_folder, boot_file)
+        # rubocop:disable Metrics/ParameterLists
+        def create_project(name, project_folder, builder_folder, template_root_folder, template, **opts)
           FileUtils.mkdir_p(project_folder)
           FileUtils.mkdir_p(builder_folder)
-          File.write(boot_file, '# Boot Sequence')
-          # Use a boot_file_template if needed
+
+          # handle_main_start_command
+
+          setup_builder_from_template(name, builder_folder, template_root_folder, 'default', **opts) unless setup_builder_from_template(name, builder_folder, template_root_folder, template, **opts)
 
           log.info 'Project created'
         end
+        # rubocop:enable Metrics/ParameterLists
+
+        def setup_builder_from_template(name, builder_folder, template_root_folder, template, **opts)
+          return false unless template
+
+          # /Users/davidcruwys/dev/kgems/k_templates/definitions/starter/ruby_gem/.starter.json
+          template_folder = File.join(template_root_folder, template)
+          starter_config = template_starter_config(template_folder)
+
+          return false unless starter_config
+
+          builder = get_builder(builder_folder, template_folder)
+
+          return false if starter_config['files'].nil? || starter_config['files'].empty?
+
+          starter_config['files']&.each do |relative_file|
+            builder.add_file(relative_file, template_file: relative_file, **{ name: name }.merge(opts))
+          end
+        end
+
+        def template_starter_config(template_folder)
+          starter_file = File.join(template_folder, '.starter.json')
+
+          return nil unless File.exist?(starter_file)
+
+          JSON.parse(File.read(starter_file))
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def get_builder(builder_folder, template_folder)
+          Handlebars::Helpers.configure do |config|
+            config.helper_config_file = File.join(Gem.loaded_specs['handlebars-helpers'].full_gem_path, '.handlebars_helpers.json')
+            config.string_formatter_config_file = File.join(Gem.loaded_specs['handlebars-helpers'].full_gem_path, '.handlebars_string_formatters.json')
+          end
+
+          KConfig.configure(:starter_template) do |config|
+            config.target_folders.add(:builder              , builder_folder)
+            config.template_folders.add(:template           , template_folder)
+          end
+
+          KBuilder::BaseBuilder.init(KConfig.configuration(:starter_template))
+        end
+        # rubocop:enable Metrics/AbcSize
 
         def can_create?(force, builder_folder)
           return true if force
@@ -63,14 +127,22 @@ module KManager
           false
         end
 
-        def log_params(name, project_folder, builder_folder, boot_file, force)
+        # rubocop:disable Metrics/ParameterLists, Metrics/AbcSize
+        def log_params(name, project_folder, builder_folder, force, log_level, template_root_folder, template, **opts)
           log.section_heading('Create new project')
-          log.kv 'name'           , name
-          log.kv 'project_folder' , project_folder
-          log.kv 'builder_folder' , builder_folder
-          log.kv 'boot_file'      , boot_file
-          log.kv 'force'          , force
+          log.kv 'name'                 , name
+          log.kv 'project_folder'       , project_folder
+          log.kv 'builder_folder'       , builder_folder
+          log.kv 'force'                , force
+          log.kv 'log_level'            , log_level
+          log.kv 'template_root_folder' , template_root_folder
+          log.kv 'template'             , template
+
+          opts.each do |key, value|
+            log.kv key, value
+          end
         end
+        # rubocop:enable Metrics/ParameterLists, Metrics/AbcSize
       end
     end
   end

data/lib/k_manager/cli/watch.rb

@@ -27,16 +27,32 @@ module KManager
 
           log_params(builder_folder, boot_file) if log_level == 'debug'
 
-          # puts builder_folder
-          # puts boot_file
+          # If you do a System Exit (control+c) you can go into a reboot sequence based on options
+          # if the option is not set then system will exit gracefully
+          while keep_watching(builder_folder, boot_file); end
+        end
+
+        private
 
+        # rubocop:disable Metrics/AbcSize
+        def keep_watching(builder_folder, boot_file)
           Dir.chdir(builder_folder) do
             watcher = KManager::Watcher.new(builder_folder, boot_file)
             watcher.start
           end
-        end
+          false
+        rescue Interrupt, SystemExit
+          if KManager.opts.reboot_on_kill == true || KManager.opts.reboot_on_kill == 1
+            puts "\nRebooting #{KManager.opts.app_name}..."
+            sleep KManager.opts.reboot_sleep unless KManager.opts.reboot_sleep.zero?
 
-        private
+            return true
+          end
+
+          puts "\nExiting..."
+          false
+        end
+        # rubocop:enable Metrics/AbcSize
 
         def log_params(builder_folder, boot_file)
           log.section_heading('Watch project')

data/lib/k_manager/manager.rb

@@ -5,6 +5,8 @@ module KManager
   #
   # TODO: Write Tests
   class Manager
+    include KLog::Logging
+
     attr_accessor :active_uri
 
     # NOTE: rename current_resource to active_resource, focused_resource?
@@ -28,7 +30,29 @@ module KManager
       yield(@current_resource)
     end
 
-    Options = Struct.new(:sleep, :exception_style)
+    # Usage
+    #
+    # KManager.opts.sleep                       = 10
+    # KManager.opts.reboot_on_kill              = 0
+    # KManager.opts.exception_style             = :short
+    # KManager.opts.show.time_taken             = true
+    # KManager.opts.show.finished               = true
+    # KManager.opts.show.finished_message       = 'FINISHED :)'
+
+    Options = Struct.new(
+      :app_name,
+      :exception_style,
+      :reboot_on_kill,
+      :reboot_sleep,
+      :sleep,
+      :show
+    )
+
+    Show = Struct.new(
+      :time_taken,
+      :finished,
+      :finished_message
+    )
 
     # @param [Integer] sleep Seconds to sleep after running, 0 = no sleep
     # @param [Symbol] exception_style Format for exception messages caught by watcher.
@@ -36,13 +60,31 @@ module KManager
     #   :short - message and short backtrace
     #   :long - message and long backtrace
     def opts
-      @opts ||= Options.new(0, :message)
+      @opts ||= Options.new('', :message, false, 1, 0, Show.new(true, true, 'FINISHED :)'))
     end
 
     def areas
       @areas ||= []
     end
 
+    # List of resources for an area.
+    #
+    # if area is nil, then return resources for the area matching the current_resource
+    def area_resources(area: nil)
+      area = resolve_area(area)
+
+      log.error 'Could not resolve area' if area.nil?
+
+      area&.resources
+    end
+
+    # List of documents for an area.
+    #
+    # if area is nil, for the area matching the current_resource
+    def area_documents(area: nil)
+      area_resources(area: area)&.flat_map(&:documents)
+    end
+
     def add_area(name, namespace: nil)
       area = find_area(name)
 
@@ -54,16 +96,7 @@ module KManager
     end
 
     def find_document(tag, area: nil)
-      area = resolve_area(area)
-
-      log.error 'Could not resolve area' if area.nil?
-
-      log.line
-      log.error(tag)
-      log.line
-
-      documents = area.resources.flat_map(&:documents)
-      documents.find { |d| d.tag == tag }
+      area_documents(area: area)&.find { |d| d.tag == tag }
     end
 
     def fire_actions(*actions)
@@ -79,14 +112,14 @@ module KManager
 
     def resolve_area(area)
       if area.nil?
-        return KManager.current_resource.area if KManager.current_resource
+        return current_resource.area if current_resource
 
-        return KManager.areas.first
+        return areas.first
       end
 
       return area if area.is_a?(Area)
 
-      find_area(name)
+      find_area(area)
     end
 
     # Return a list of resources for a URI.
@@ -104,7 +137,19 @@ module KManager
       @active_uri = nil
     end
 
+    def boot
+      KManager.fire_actions(:load_content, :register_document, :preload_document, :load_document)
+    end
+
+    def reboot
+      puts 'Fire reboot'
+      KManager.opts.reboot_on_kill = 1
+      raise SystemExit
+    end
+
     def debug(*sections)
+      log.structure(KUtil.data.to_hash(opts))
+
       areas.each do |area|
         area.debug(*sections)
       end

data/lib/k_manager/overview/dashboard.rb

@@ -5,6 +5,10 @@ module KManager
     # Generate dashboard information on the console
     #
     # TODO: ConsoleDashboard and HtmlConsole
+    # dashboard = KManager::Overview::Dashboard.new(KManager.manager)
+    # dashboard.areas
+    # dashboard.resources
+    # dashboard.documents
     class Dashboard
       include KLog::Logging
 
@@ -45,7 +49,7 @@ module KManager
               { namespace:      { display_method: ->(row) { row.namespace } } },
               { status:         { display_method: ->(row) { row.status } } },
               { content_type:   { display_method: ->(row) { row.content_type } } },
-              { content:        { display_method: ->(row) { row.content } } },
+              { content:        { display_method: ->(row) { format_content(row.content, row.content_type) }, width: 50 } },
               { document_count: { display_method: ->(row) { blank_zero(row.document_count) } } },
               { valid:          { display_method: ->(row) { row.valid } } },
               { error_count:    { display_method: ->(row) { blank_zero(row.errors.length) } } },
@@ -83,6 +87,7 @@ module KManager
               # # { path:               { display_method: -> (row) { row.resource_path } } },
               # { exist:              { display_method: -> (row) { row.resource_exist } } },
               { document_id:        { display_method: ->(row) { blank_zero(row.document_id) } } },
+              { state:              { display_method: ->(row) { document_state(row.document_state) } } },
               { data:               { display_method: ->(row) { row.document_data } } },
               { error_count:        { display_method: ->(row) { blank_zero(row.document_errors.length) } } },
               { key:                { display_method: ->(row) { row.document_key } } },
@@ -119,12 +124,35 @@ module KManager
         log.structure(data, **opts)
       end
 
+      def format_content(content, type)
+        formatted = content
+        case type
+        when :ruby
+          formatted = formatted&.sub(/\A# frozen_string_literal: true/, '')&.strip
+        end
+        formatted
+      end
+
       def blank_zero(value)
         return nil if value.nil? || (value.is_a?(Integer) && value.zero?)
 
         value
       end
 
+      # Valid states are:
+      #   :new
+      #   :evaluated
+      #   :initialized
+      #   :children_evaluated
+      #   :actioned
+      def document_state(state)
+        return 'unknown'                  if state.nil?
+        return 'loaded (partially)'       if state == :evaluated # probably has unmet dependency
+        return 'loaded'                   if state == :children_evaluated
+
+        state.to_s
+      end
+
       def lpad(size, value)
         value.to_s.rjust(size)
       end

data/lib/k_manager/overview/models.rb

@@ -62,9 +62,12 @@ module KManager
       attribute :resource_relative_path   , Types::Strict::String.optional.default(nil)
       attribute :resource_exist?          , Types::Strict::Bool
       attribute :document_id              , Types::Strict::Integer
+      attribute :document_state           , Types::Strict::String | Types::Strict::Symbol
       attribute :document_data            , Types::Strict::Any.optional.default # Hash.optional.default(nil) | Types::Strict::Array.of(Types::Strict::Hash).optional.default(nil)
       attribute :document_key             , Types::Strict::String | Types::Strict::Symbol
-      attribute :document_namespace       , Types::Strict::String | Types::Strict::Array.of(Types::Strict::String).optional.default(nil)
+      attribute :document_namespace       , Types::Strict::String | Types::Strict::Symbol |
+                                            Types::Strict::Array.of(Types::Strict::String).optional.default(nil) |
+                                            Types::Strict::Array.of(Types::Strict::Symbol).optional.default(nil)
       attribute :document_tag             , Types::Strict::String | Types::Strict::Symbol
       attribute :document_type            , Types::Strict::String | Types::Strict::Symbol
       # TODO: Write code to populate this with the resource line number

data/lib/k_manager/overview/queries.rb

@@ -35,6 +35,7 @@ module KManager
                 **area.attribute_values('area_'),
                 **resource.attribute_values('resource_'),
                 document_id: document.object_id,
+                document_state: document.block_state,
                 document_data: document.data,
                 document_key: document.key,
                 document_namespace: document.namespace,

data/lib/k_manager/resources/base_resource.rb

@@ -25,7 +25,7 @@ module KManager
       include KLog::Logging
       include KDoc::Guarded
 
-      ACTIONS = %i[load_content register_document load_document].freeze
+      ACTIONS = %i[load_content register_document preload_document load_document].freeze
 
       class << self
         def valid_action?(action)
@@ -42,6 +42,8 @@ module KManager
       # - :content_loaded
       # - :documents_registering
       # - :documents_registered
+      # - :documents_preloading
+      # - :documents_preloaded
       # - :documents_loading
       # - :documents_loaded
       attr_reader :status
@@ -102,9 +104,9 @@ module KManager
       end
 
       # TODO: Is this really needed?
-      def document
-        @document ||= documents&.first
-      end
+      # def document
+      #   @document ||= documents&.first
+      # end
 
       def activated?
         # log.section_heading("Am I activated?")
@@ -120,7 +122,8 @@ module KManager
       # @param [Symbol] action what action is to be fired
       #  - :load_content for loading text content
       #  - :register_document for registering 1 or more documents (name and namespace) against the resource
-      #  - :load_document for parsing the content into a document
+      #  - :preload_document for parsing the content into a document
+      #  - :load_document for finalizing the document load with met dependencies and action execution if applicable
       # rubocop:disable Metrics/CyclomaticComplexity
       def fire_action(action)
         # TODO: Write test for valid
@@ -131,20 +134,25 @@ module KManager
           load_content_action if alive?
         when :register_document
           register_document_action if content_loaded?
+        when :preload_document
+          preload_document_action if documents_registered?
         when :load_document
-          load_document_action if documents_registered?
+          load_document_action if documents_preloaded?
         else
           log.warn "Action: '#{action}' is invalid for status: '#{status}'"
         end
       end
       # rubocop:enable Metrics/CyclomaticComplexity
 
+      # I don't think this is needed, it is never really used
       def fire_next_action
         if alive?
           fire_action(:load_content)
         elsif content_loaded?
           fire_action(:register_document)
         elsif documents_registered?
+          fire_action(:preload_document)
+        elsif documents_preloaded?
           fire_action(:load_document)
         end
       end
@@ -162,20 +170,30 @@ module KManager
       end
 
       def register_document
-        # log.warn 'you need to implement register_document'
         KManager::Resources::ResourceDocumentFactory.create_documents(self)
       end
 
+      # rubocop:disable Lint/RescueException
+      def preload_document
+        documents.each(&:execute_block)
+      rescue Exception => e
+        guard(e.message)
+        debug
+        log.exception(e, style: KManager.opts.exception_style)
+        # log.exception(e, style: :short)
+      end
+      # rubocop:enable Lint/RescueException
+
       # rubocop:disable Lint/RescueException
       def load_document
-        # log.warn 'you need to implement register_document'
         documents.each do |document|
           document.execute_block(run_actions: activated?)
         end
       rescue Exception => e
         guard(e.message)
         debug
-        log.exception(e, style: :short)
+        log.exception(e, style: KManager.opts.exception_style)
+        # log.exception(e, style: :short)
       end
       # rubocop:enable Lint/RescueException
 
@@ -239,6 +257,10 @@ module KManager
         @status == :documents_registered
       end
 
+      def documents_preloaded?
+        @status == :documents_preloaded
+      end
+
       def documents_loaded?
         @status == :documents_loaded
       end
@@ -317,14 +339,18 @@ module KManager
       def register_document_action
         @status = :documents_registering
         register_document
-        # document_factory.create_documents
         @status = :documents_registered
       end
 
+      def preload_document_action
+        @status = :documents_preloading
+        preload_document
+        @status = :documents_preloaded
+      end
+
       def load_document_action
         @status = :documents_loading
         load_document
-        # document_factory.parse_content
         @status = :documents_loaded
       end
     end

data/lib/k_manager/resources/resource_document_factory.rb

@@ -89,6 +89,8 @@ module KManager
           # if documents.length > 0
           #   resource.resource_type = KDsl::Resources::Resource::TYPE_RUBY_DSL
           # end
+        rescue Interrupt, SystemExit
+          raise
         rescue Exception => e
           # Report the error but still add the document so that you can see
           # it in the ResourceDocument list, it will be marked as Error

data/lib/k_manager/resources/resource_manager.rb

@@ -93,8 +93,13 @@ module KManager
         replace_resource = resource.recreate(resource)
         replace_resource.fire_action(:load_content)
         replace_resource.fire_action(:register_document)
+        replace_resource.fire_action(:preload_document)
         replace_resource.fire_action(:load_document)
         resource_set.replace(replace_resource)
+
+        # This is a bit of a hack, but it works for now
+        # TODO: I don't think is actually working.
+        attach_dependencies
       end
 
       def delete_resource(resource_uri)
@@ -146,6 +151,7 @@ module KManager
 
         load_content        if actions.include?(:load_content)
         register_documents  if actions.include?(:register_document)
+        preload_documents   if actions.include?(:preload_document)
         load_documents      if actions.include?(:load_document)
       end
 
@@ -167,18 +173,45 @@ module KManager
         end
       end
 
+      def preload_documents
+        # first pass will attempt to load every document, if a document has dependencies
+        # it will be loaded in a second pass after dependencies are available
+        resources.each do |resource|
+          resource.fire_action(:preload_document)
+        end
+
+        attach_dependencies
+      end
+
       def load_documents
+        # second pass will finalize any documents that were partially load due to dependencies
         resources.each do |resource|
           resource.fire_action(:load_document)
         end
       end
 
+      def find_document(tag)
+        resources.flat_map(&:documents).find { |d| d.tag == tag }
+      end
+
       def debug
         resources.each(&:debug)
+        nil
       end
 
       private
 
+      def attach_dependencies
+        documents_with_unmet_dependencies = resources.flat_map(&:documents).reject(&:dependencies_met?)
+
+        documents_with_unmet_dependencies.each do |document|
+          document.depend_on_tags.each do |tag|
+            dependant_document = find_document(tag)
+            document.resolve_dependency(dependant_document) if dependant_document
+          end
+        end
+      end
+
       def parse_uri(uri)
         return uri if uri.is_a?(URI)
         return URI.parse(uri) if uri =~ URI::ABS_URI # https://stackoverflow.com/questions/1805761/how-to-check-if-a-url-is-valid

data/lib/k_manager/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module KManager
-  VERSION = '0.0.24'
+  VERSION = '0.0.32'
 end