k_manager 0.0.13 → 0.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e1e2ee281f38810223b80d27b7ed6ba17f6d766c9bc3362925cb781faea6e6f
-  data.tar.gz: cce3bcc06ce095f5f00c55bc60ac47b0ea493930db4ebed635fe106303cf5957
+  metadata.gz: 2024c747b3ae20e56a669bda4c2940274007a63545759cf1fc93adc0a9ae5b40
+  data.tar.gz: 12030613016449e807b986cc368330bf6d4667cd89833051511c48ff7dd21c0b
 SHA512:
-  metadata.gz: 7c6154b2a689a193cc88415d89959ca564783b04ee256a74c9a845c3d94102c2ae69be11d47e6cf01cc8e75ca52784d2f4a5b4cb8f373be074112464e7a1da5c
-  data.tar.gz: 70e7121af0c37a4458670b4668e4e8a9f0e4c798e317bca98ccdb27414529b4b7966373f0689a654991eefabdd9af783536aba33691c54b844cc51ade55071c5
+  metadata.gz: f8746ca5b44f389938b92f8a17ca9c7947e560fc65046c5b780cbca3bcbfc0180e9035002cb0a9cc00c9b0f0e70277f7b631523e5b9976bdeff9adac19389eab
+  data.tar.gz: dba116da1e201cd22c39a2fdc68805dd9e8d019bfbdb7b5eb6a0d7bd283fb99a07dded3762b8c7b484a3015e62fd98ed29b16ee05ac0d8b7192049b4dde17a25

data/.rubocop.yml

@@ -7,6 +7,7 @@ AllCops:
   Exclude:
     - "_/**/*"
     - "spec/samples/**/*"
+    - "spec/k_manager/scenarios/**/*"
 
 Metrics/BlockLength:
   Exclude:

data/Gemfile

@@ -23,3 +23,21 @@ group :development, :test do
   gem 'rubocop-rake', require: false
   gem 'rubocop-rspec', require: false
 end
+
+# If local dependency
+if ENV['KLUE_LOCAL_GEMS']&.to_s&.downcase == 'true'
+  group :development, :test do
+    puts 'Using Local GEMs'
+    gem 'handlebars-helpers'      , path: '../handlebars-helpers'
+    gem 'k_builder'               , path: '../k_builder'
+    gem 'k_builder-dotnet'        , path: '../k_builder-dotnet'
+    gem 'k_builder-package_json'  , path: '../k_builder-package_json'
+    gem 'k_builder-webpack5'      , path: '../k_builder-webpack5'
+    gem 'k_decor'                 , path: '../k_decor'
+    gem 'k_doc'                   , path: '../k_doc'
+    gem 'k_domain'                , path: '../k_domain'
+    gem 'k_log'                   , path: '../k_log'
+    gem 'k_type'                  , path: '../k_type'
+    gem 'k_util'                  , path: '../k_util'
+  end
+end

data/Rakefile

@@ -8,6 +8,8 @@ require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 require 'k_manager/version'
 
+Dir.glob('tasks/*.rake').each { |r| import r }
+
 RSpec::Core::RakeTask.new(:spec)
 
 require 'rake/extensiontask'

data/docs/flow.drawio

@@ -0,0 +1,16 @@
+<mxfile host="65bd71144e">
+    <diagram id="AE9tsI4e_FXgj975v7li" name="Page-1">
+        <mxGraphModel dx="1087" dy="583" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="1169" pageHeight="827" background="#ffffff" math="0" shadow="0">
+            <root>
+                <mxCell id="0"/>
+                <mxCell id="1" parent="0"/>
+                <mxCell id="2" value="KManager" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1">
+                    <mxGeometry x="200" y="70" width="120" height="60" as="geometry"/>
+                </mxCell>
+                <mxCell id="3" value="" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1">
+                    <mxGeometry x="390" y="210" width="120" height="60" as="geometry"/>
+                </mxCell>
+            </root>
+        </mxGraphModel>
+    </diagram>
+</mxfile>

data/exe/k_manager

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+require 'pry'
+
+lib_path = File.expand_path(File.join(File.dirname(__FILE__), '../lib'))
+gem_path = File.expand_path(File.join(File.dirname(__FILE__), '../Gemfile'))
+
+$LOAD_PATH.unshift(lib_path)
+
+ENV['BUNDLE_GEMFILE'] = gem_path
+
+require 'bundler/setup'
+require 'k_manager'
+
+puts 'david'
+# options = KBuilder::Watch::Cli.parse_options
+
+# KBuilder::Watch::Execute.new(options).run

data/k_manager.gemspec

@@ -38,10 +38,16 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
   # spec.extensions    = ['ext/k_manager/extconf.rb']
 
+  spec.add_dependency 'dry-struct', '~> 1'
+  spec.add_dependency 'filewatcher', '~> 2.0.0.beta5'
   spec.add_dependency 'k_builder', '~> 0.0.0'
   spec.add_dependency 'k_doc', '~> 0.0.0'
   spec.add_dependency 'k_ext-github', '~> 0.0.0'
+  spec.add_dependency 'k_fileset', '~> 0.0.0'
   spec.add_dependency 'k_log', '~> 0.0.0'
   # spec.add_dependency 'k_type'                , '~> 0.0.0'
   # spec.add_dependency 'k_util'                , '~> 0.0.0'
+  spec.metadata = {
+    'rubygems_mfa_required' => 'true'
+  }
 end

data/lib/k_manager/area.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module KManager
+  class Area
+    include KLog::Logging
+    extend Forwardable
+
+    # TODO: I have not got a use for area name yet, it may be able to drive default config, but not sure.
+    attr_reader :name
+    attr_reader :namespace
+    attr_reader :config
+
+    def initialize(**opts)
+      @name       = opts[:name]
+
+      raise 'Area name is required' unless @name
+
+      @namespace  = opts[:namespace] || @name
+      @config     = KBuilder.configuration(@name)
+    end
+
+    def resource_manager
+      @resource_manager ||= KManager::Resources::ResourceManager.new(self)
+    end
+
+    def_delegators :resource_manager, :resource_changed
+
+    def debug(*sections)
+      log.kv 'Area'           , name
+      log.kv 'Namespace'      , namespace
+
+      resource_manager.debug if sections.include?(:resource) || sections.include?(:resources)
+      config.debug if sections.include?(:config)
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def attribute_values(prefix = nil)
+      result = {}
+      result["#{prefix}name".to_sym]                  = name
+      result["#{prefix}namespace".to_sym]             = namespace
+      result["#{prefix}resource_count".to_sym]        = resource_manager.resources.length
+      result["#{prefix}document_count".to_sym]        = resource_manager.resources.sum { |resource| resource.documents.length }
+      result
+    end
+    # rubocop:enable Metrics/AbcSize
+  end
+end

data/lib/k_manager/document_factory.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module KManager
+  # Factories for creating common DSL documents quickly
+  #
+  # Example:
+  #
+  #   KManager.csv(file: 'somepath/somefile.csv') do
+  #     load
+  #   end
+  class DocumentFactory
+    include KLog::Logging
+
+    # Create a KDoc::Model instance
+    def model(key = nil, **opts, &block)
+      document = new_document(KDoc::Model, key, **opts, &block)
+
+      attach_to_current_resource(document, change_content_type: :dsl)
+    end
+
+    # Create a KDoc::CsvDoc instance
+    def csv(key = nil, **opts, &block)
+      document = new_document(KDoc::CsvDoc, key, **opts, &block)
+
+      attach_to_current_resource(document, change_content_type: :dsl)
+    rescue StandardError => e
+      log.error(e)
+    end
+
+    # Create a KDoc::JsonDoc instance
+    def json(key = nil, **opts, &block)
+      document = new_document(KDoc::JsonDoc, key, **opts, &block)
+
+      attach_to_current_resource(document, change_content_type: :dsl)
+    rescue StandardError => e
+      log.error(e)
+    end
+
+    # Create a KDoc::YamlDoc instance
+    def yaml(key = nil, **opts, &block)
+      document = new_document(KDoc::YamlDoc, key, **opts, &block)
+
+      attach_to_current_resource(document, change_content_type: :dsl)
+    rescue StandardError => e
+      log.error(e)
+    end
+
+    private
+
+    # If document gets created dynamically due to class_eval then they
+    # can attach themselves to the currently focussed resource.
+    #
+    # It will throw an error if for_resource has not been called earlier
+    # in the thread lifecycle.
+    def attach_to_current_resource(document, change_content_type: nil)
+      return document unless KManager.current_resource
+
+      KManager.for_current_resource do |resource|
+        resource.attach_document(document, change_content_type: change_content_type)
+      end
+    end
+
+    # Create an instance of a document
+    #
+    # @param [Class<DocumentTaggable>] klass type of document to create
+    def new_document(klass, key = nil, **opts, &block)
+      # Should be able to infer
+      # key = KManager.current_resource.documents.length.zero? ? KManager.current_resource.infer_key : nil
+
+      # klass.new(key, **{ owner: KManager.current_resource }.merge(opts), &block)
+      klass.new(key, **opts, &block)
+    end
+  end
+end

data/lib/k_manager/manager.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module KManager
+  # KManager is designed to work with one or more areas of concern
+  #
+  # TODO: Write Tests
+  class Manager
+    def areas
+      @areas ||= []
+    end
+
+    def add_area(name, namespace: nil)
+      area = find_area(name)
+
+      return area if area
+
+      area = KManager::Area.new(name: name, namespace: namespace)
+      areas << area
+      area
+    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 resource_changed(uri, state)
+      areas.each do |area|
+        area.resource_changed(uri, state)
+      end
+    end
+
+    def debug(*sections)
+      areas.each do |area|
+        area.debug(*sections)
+      end
+    end
+
+    # # 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,187 @@
+# 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) { row.content } } },
+              { 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 } } }
+            ]
+          }
+        }
+
+        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 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::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