k_manager 0.0.13 → 0.0.28

data/lib/k_manager/manager.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module KManager
+  # KManager is designed to work with one or more areas of concern
+  #
+  # TODO: Write Tests
+  class Manager
+    attr_accessor :active_uri
+
+    # NOTE: rename current_resource to active_resource, focused_resource?
+    attr_reader :current_resource
+
+    def resource_mutex
+      @resource_mutex ||= Mutex.new
+    end
+
+    def for_resource(resource = nil)
+      resource_mutex.synchronize do
+        @current_resource = resource
+        yield(current_resource)
+        @current_resource = nil
+      end
+    end
+
+    def for_current_resource
+      raise KManager::Error, 'Attempting to yield current_resource, when a different thread has the lock?' unless resource_mutex.owned?
+
+      yield(@current_resource)
+    end
+
+    # 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.
+    #   :message - message only
+    #   :short - message and short backtrace
+    #   :long - message and long backtrace
+    def opts
+      @opts ||= Options.new('', :message, false, 1, 0, Show.new(true, true, 'FINISHED :)'))
+    end
+
+    def areas
+      @areas ||= []
+    end
+
+    def add_area(name, namespace: nil)
+      area = find_area(name)
+
+      return area if area
+
+      area = KManager::Area.new(manager: self, name: name, namespace: namespace)
+      areas << area
+      area
+    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 }
+    end
+
+    def fire_actions(*actions)
+      areas.each do |area|
+        # delegate
+        area.resource_manager.fire_actions(*actions)
+      end
+    end
+
+    def find_area(name)
+      areas.find { |a| a.name == name }
+    end
+
+    def resolve_area(area)
+      if area.nil?
+        return KManager.current_resource.area if KManager.current_resource
+
+        return KManager.areas.first
+      end
+
+      return area if area.is_a?(Area)
+
+      find_area(name)
+    end
+
+    # Return a list of resources for a URI.
+    #
+    # Generally only one resource is returned, unless the URI exists in more than one area
+    def resources_by_uri(uri)
+      areas.map { |area| area.resources_by_uri(uri) }.compact
+    end
+
+    def resource_changed(uri, state)
+      @active_uri = uri
+      areas.each do |area|
+        area.resource_changed(uri, state)
+      end
+      @active_uri = nil
+    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
+    end
+
+    # def cons
+
+    # # May replace config with default channel name
+    # # Channels represent configurations that are independent of project or builder,
+    # # but a project may want to have a default channel that it supplies
+    # def initialize(name, config = nil, **opts)
+    #   raise KType::Error, 'Provide a project name' unless name.is_a?(String) || name.is_a?(Symbol)
+
+    #   @name = name
+    #   @config = config || KManager::Configuration::ProjectConfig.new
+    #   @resources = []
+
+    #   initialize_opts(opts)
+    # end
+  end
+end

data/lib/k_manager/overview/dashboard.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module KManager
+  module Overview
+    # Generate dashboard information on the console
+    #
+    # TODO: ConsoleDashboard and HtmlConsole
+    class Dashboard
+      include KLog::Logging
+
+      attr_reader :queries
+
+      def initialize(manager)
+        @queries = KManager::Overview::Queries.new(manager)
+      end
+
+      def areas
+        data = queries.areas.map { |hash| KManager::Overview::Area.new(hash) }
+        graph = {
+          areas: {
+            columns: [
+              :name,
+              :namespace,
+              { resource_count: { display_method: ->(row) { blank_zero(row.resource_count) } } },
+              { document_count: { display_method: ->(row) { blank_zero(row.document_count) } } }
+
+            ]
+          }
+        }
+        display(:areas, 'Areas', graph, data)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def resources
+        # sort and remove repeating area
+        data = grouped_resources(queries.resources).map { |hash| KManager::Overview::Resource.new(hash) }
+        graph = {
+          resources: {
+            columns: [
+              { area:           { display_method: ->(row) { row.area_name } } },
+              { area_ns:        { display_method: ->(row) { row.area_namespace } } },
+              { resource_docs:  { display_method: ->(row) { resource_document_count(row) } } },
+              { resource_id:    { display_method: ->(row) { blank_zero(row.id) } } },
+              { key:            { display_method: ->(row) { row.key } } },
+              { namespace:      { display_method: ->(row) { row.namespace } } },
+              { status:         { display_method: ->(row) { row.status } } },
+              { content_type:   { display_method: ->(row) { row.content_type } } },
+              { 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) } } },
+              { scheme:         { display_method: ->(row) { row.scheme } } },
+              { root:           { display_method: ->(row) { row.scheme == :file ? '' : row.host } } },
+              { relative_path:  { display_method: ->(row) { right(50, row.relative_path) }, width: 50 } },
+              { exist:          { display_method: ->(row) { row.exist } } } # ,
+              # { resource_path:  { display_method: ->(row) { row.path }, width: 100 } }
+            ]
+          }
+        }
+
+        display(:resources, 'Resource List', graph, data)
+      end
+
+      def documents
+        data = grouped_documents(queries.documents).map { |hash| KManager::Overview::Document.new(hash) }
+
+        graph = {
+          resources: {
+            columns: [
+              { area:               { display_method: ->(row) { row.area_name } } },
+              { area_ns:            { display_method: ->(row) { row.area_namespace } } },
+              { resource_docs:      { display_method: ->(row) { resource_document_count(row) } } },
+              { resource_id:        { display_method: ->(row) { blank_zero(row.resource_id) } } },
+              # { key:                { display_method: -> (row) { row.resource_key } } },
+              # { namespace:          { display_method: -> (row) { row.resource_namespace } } },
+              # { status:             { display_method: -> (row) { row.resource_status } } },
+              # { content_type:       { display_method: -> (row) { row.resource_content_type } } },
+              # { content:            { display_method: -> (row) { row.resource_content } } },
+              # { document_count:     { display_method: -> (row) { blank_zero(row.resource_document_count) } } },
+              # { valid:              { display_method: -> (row) { row.resource_valid } } },
+              # { error_count:        { display_method: -> (row) { blank_zero(row.resource_errors.length) } } },
+              # { scheme:             { display_method: -> (row) { row.resource_scheme } } },
+              # # { path:               { display_method: -> (row) { row.resource_path } } },
+              # { exist:              { display_method: -> (row) { row.resource_exist } } },
+              { document_id:        { display_method: ->(row) { blank_zero(row.document_id) } } },
+              { 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 } } },
+              { namespace:          { display_method: ->(row) { row.document_namespace } } },
+              { tag:                { display_method: ->(row) { row.document_tag } } },
+              { type:               { display_method: ->(row) { row.document_type } } },
+              { relative_path:      { display_method: ->(row) { right(50, resource_path_location(row.resource_relative_path, row.document_location)) }, width: 50 } }
+            ]
+          }
+        }
+
+        display(:resources, 'Document List', graph, data)
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      private
+
+      def resource_path_location(path, location)
+        return path unless location
+
+        "#{path}:#{location}"
+      end
+
+      def display(section, title, graph, data)
+        data = {
+          section => data
+        }
+        opts = {
+          title: title,
+          title_type: :heading,
+          show_array_count: false,
+          graph: graph
+        }
+        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
+
+      def lpad(size, value)
+        value.to_s.rjust(size)
+      end
+
+      def right(size, value)
+        value.chars.last(size).join
+      end
+
+      def resource_document_count(row)
+        return nil if row.area_resource_count.nil? && row.area_document_count.nil?
+
+        resource = lpad(2, blank_zero(row.area_resource_count))
+        document = lpad(2, blank_zero(row.area_document_count))
+        [resource, document].join(' / ')
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def grouped_resources(resources)
+        return resources if resources.length < 2
+
+        grouped = resources.group_by { |resource| resource[:area_name] }
+        grouped.flat_map do |group|
+          group[1].map.with_index do |resource, index|
+            new_resource = resource.clone
+            if index.positive?
+              new_resource[:area_name]            = nil
+              new_resource[:area_namespace]       = nil
+              new_resource[:area_resource_count]  = nil
+              new_resource[:area_document_count]  = nil
+            end
+            new_resource
+          end
+        end
+      end
+
+      def grouped_documents(documents)
+        return documents if documents.length < 2
+
+        grouped = documents.group_by { |document| document[:area_name] }
+        grouped.flat_map do |group|
+          last_resource_id = 0
+          group[1].map.with_index do |document, index|
+            new_document = document.clone
+            if index.positive?
+              new_document[:area_name]            = nil
+              new_document[:area_namespace]       = nil
+              new_document[:area_resource_count]  = nil
+              new_document[:area_document_count]  = nil
+
+              new_document[:resource_id] = nil if last_resource_id == group[1][index][:resource_id]
+
+            end
+            last_resource_id = document[:resource_id]
+            new_document
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/k_manager/overview/dump_json.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module KManager
+  module Overview
+    class DumpJson
+      attr_reader :path
+      attr_reader :queries
+
+      def initialize(path, manager)
+        @path = path
+        @queries = KManager::Overview::Queries.new(manager)
+      end
+
+      def areas(file_name)
+        dump(file_name, queries.areas)
+      end
+
+      def resources(file_name)
+        dump(file_name, queries.resources)
+      end
+
+      def documents(file_name)
+        dump(file_name, queries.documents)
+      end
+
+      private
+
+      def dump(file_name, data)
+        file = File.join(path, file_name)
+        json = JSON.pretty_generate(data)
+        File.write(file, json)
+      end
+    end
+  end
+end

data/lib/k_manager/overview/models.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# KDomain::Schemas::Domain::Column
+# KDomain::Schemas::Domain::Model
+
+module KManager
+  module Overview
+    module Types
+      include Dry.Types()
+    end
+
+    class Error < Dry::Struct
+    end
+
+    class Area < Dry::Struct
+      attribute :name                     , Types::Strict::String | Types::Strict::Symbol
+      attribute :namespace                , Types::Strict::String.optional.default(nil) | Types::Strict::Symbol.optional.default(nil)
+      attribute :resource_count           , Types::Strict::Integer
+      attribute :document_count           , Types::Strict::Integer
+    end
+
+    class Resource < Dry::Struct
+      attribute :area_name                , Types::Strict::String.optional.default(nil) | Types::Strict::Symbol.optional.default(nil)
+      attribute :area_namespace           , Types::Strict::String.optional.default(nil) | Types::Strict::Symbol.optional.default(nil)
+      attribute :area_resource_count      , Types::Strict::Integer.optional.default(nil)
+      attribute :area_document_count      , Types::Strict::Integer.optional.default(nil)
+      attribute :id                       , Types::Strict::Integer
+      attribute :key                      , Types::Strict::String
+      attribute :namespace                , Types::Strict::String | Types::Strict::Array.of(Types::Strict::String).optional.default(nil)
+      attribute :status                   , Types::Strict::String | Types::Strict::Symbol
+      attribute :source                   , Types::Strict::String
+      attribute :content_type             , Types::Strict::String | Types::Strict::Symbol
+      attribute :content                  , Types::Strict::String.optional.default(nil)
+      attribute :document_count           , Types::Strict::Integer
+      attribute :errors                   , Types::Strict::Array.of(KManager::Overview::Error).optional.default(nil)
+      attribute :valid?                   , Types::Strict::Bool
+      attribute :scheme                   , Types::Strict::String | Types::Strict::Symbol
+      attribute :host                     , Types::Strict::String
+      attribute :path                     , Types::Strict::String
+      attribute :relative_path            , Types::Strict::String.optional.default(nil)
+      attribute :exist?                   , Types::Strict::Bool
+    end
+
+    class Document < Dry::Struct
+      attribute :area_name                , Types::Strict::String.optional.default(nil) | Types::Strict::Symbol.optional.default(nil)
+      attribute :area_namespace           , Types::Strict::String.optional.default(nil) | Types::Strict::Symbol.optional.default(nil)
+      attribute :area_resource_count      , Types::Strict::Integer.optional.default(nil)
+      attribute :area_document_count      , Types::Strict::Integer.optional.default(nil)
+      attribute :resource_id              , Types::Strict::Integer.optional.default(nil)
+      attribute :resource_key             , Types::Strict::String
+      attribute :resource_namespace       , Types::Strict::Array.of(Types::Strict::String).optional.default(nil)
+      attribute :resource_status          , Types::Strict::String | Types::Strict::Symbol
+      attribute :resource_source          , Types::Strict::String
+      attribute :resource_content_type    , Types::Strict::String | Types::Strict::Symbol
+      attribute :resource_content         , Types::Strict::String.optional.default(nil)
+      attribute :resource_document_count  , Types::Strict::Integer
+      attribute :resource_errors          , Types::Strict::Array.of(KManager::Overview::Error).optional.default(nil)
+      attribute :resource_valid?          , Types::Strict::Bool
+      attribute :resource_scheme          , Types::Strict::String | Types::Strict::Symbol
+      attribute :resource_host            , Types::Strict::String
+      attribute :resource_path            , Types::Strict::String
+      attribute :resource_relative_path   , Types::Strict::String.optional.default(nil)
+      attribute :resource_exist?          , Types::Strict::Bool
+      attribute :document_id              , Types::Strict::Integer
+      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_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
+      attribute :document_location        , Types::Strict::Integer.optional.default(nil)
+      attribute :document_errors          , Types::Strict::Array.of(KManager::Overview::Error).optional.default(nil)
+      attribute :document_valid?          , Types::Strict::Bool
+    end
+  end
+end

data/lib/k_manager/overview/queries.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module KManager
+  module Overview
+    class Queries
+      attr_reader :manager
+
+      def initialize(manager)
+        @manager = manager
+      end
+
+      def areas
+        manager.areas.map(&:attribute_values)
+      end
+
+      def resources
+        manager.areas.flat_map do |area|
+          # TODO: Some of these properties are only available on FileResource
+          #       This will need to be refactored when implementing Mem and Web Resource
+          area.resource_manager.resource_set.resources.map do |resource|
+            {
+              **area.attribute_values('area_'),
+              **resource.attribute_values('')
+            }
+          end
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def documents
+        manager.areas.flat_map do |area|
+          area.resource_manager.resource_set.resources.flat_map do |resource|
+            resource.documents.map do |document|
+              {
+                **area.attribute_values('area_'),
+                **resource.attribute_values('resource_'),
+                document_id: document.object_id,
+                document_data: document.data,
+                document_key: document.key,
+                document_namespace: document.namespace,
+                document_tag: document.tag,
+                document_type: document.type,
+                document_errors: document.error_hash,
+                document_valid: document.valid?
+              }
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end