k_manager 0.0.13 → 0.0.28

data/lib/k_manager/resources/base_resource.rb

@@ -5,6 +5,8 @@ module KManager
     # A resource represents text based content in the project. The content
     # maybe data, interpreted ruby code or a combination of the two.
     #
+    # Any non-binary file that is useful for processing.
+    #
     # Currently resources refer to file based content, but it is envisaged
     # that resources could come from a distributed source such as Gist,
     # WebService, or even FTP.
@@ -21,9 +23,21 @@ module KManager
     # generally only one document.
     class BaseResource
       include KLog::Logging
+      include KDoc::Guarded
+
+      ACTIONS = %i[load_content register_document load_document].freeze
+
+      class << self
+        def valid_action?(action)
+          ACTIONS.include?(action)
+        end
+      end
+
+      attr_reader :uri # https://ruby-doc.org/stdlib-2.6.1/libdoc/uri/rdoc/URI/Generic.html
 
+      # TODO: Refactor from status to state and extract to a State class
       # Status of the resource
-      # - :initialized
+      # - :alive (i am alive, or instantiated)
       # - :content_loading
       # - :content_loaded
       # - :documents_registering
@@ -32,17 +46,25 @@ module KManager
       # - :documents_loaded
       attr_reader :status
 
-      # Where is the source of content
+      # What content type does the underlying resource type generally contain
       #
-      # Implement in child classes, examples: :file, :uri, :dynamic
-      attr_reader :source
-
-      # Where is the type of the
+      # Examples:
       #
-      # Implement in child classes, examples: :csv, :json, :ruby, :dsl, :yaml
-      attr_reader :type
+      # :csv        - CSV text content
+      # :json       - JSON text content
+      # :yaml       - YAML text content
+      # :xml        - XML text content
+      # :ruby       - Ruby code file of unknown capability
+      # :ruby_dsl   - Ruby code holding some type of known DSL such as a KDoc
+      #               DISCUSS: should this subtype be delegated to an attribute on a responsible class
+      attr_reader :content_type
+
+      # TODO: Write Test
+      # Area is an option property what will only be set when working with Area
+      attr_accessor :area
 
-      attr_reader :project
+      # Optional namespace that the resource belongs to.
+      attr_reader :namespace
 
       # Content of resource, use read content to load this property
       attr_reader :content
@@ -60,40 +82,70 @@ module KManager
       #
       # @param [Hash] **opts Options for initializing the resource
       # @option opts [Project] :project attach the resource to a project
-      def initialize(**opts)
-        @status = :initialized
-        @source = :unknown
-        @type = :unknown
+      # NAMESPACE can probably be taken from file set relative path
+      def initialize(uri, **opts)
+        self.uri      = uri
 
-        attach_project(opts[:project]) if opts[:project]
+        @status       = :alive
+        @area         = value_remove(opts, :area)
+        @namespace    = value_remove(opts, :namespace)
+        @content_type = @content_type || value_remove(opts, :content_type) || infer_content_type || default_content_type
+        @content      = value_remove(opts, :content)
+
+        # attach_project(opts[:project]) if opts[:project]
         @documents = []
       end
 
-      def attach_project(project)
-        @project = project
-        @project.add_resource(self)
-        self
+      def source_path
+        # Expectation that uri is of type URI::HTTP or URI::HTTPS
+        uri.to_s
       end
 
+      # TODO: Is this really needed?
       def document
         @document ||= documents&.first
       end
 
+      def activated?
+        # log.section_heading("Am I activated?")
+        # log.kv 'URI', uri
+        # log.kv 'ACTIVE URI', self.area.manager.active_uri
+        return false if area.nil?
+
+        uri.to_s == area.manager.active_uri.to_s
+      end
+
       # Fire actions and keep track of status as they fire
       #
       # @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
+      # rubocop:disable Metrics/CyclomaticComplexity
       def fire_action(action)
-        if action == :load_content && @status == :initialized
-          load_content_action
-        elsif action == :register_document && @status == :content_loaded
-          register_document_action
-        elsif action == :load_document && @status == :documents_registered
-          load_document_action
+        # TODO: Write test for valid
+        return unless valid?
+
+        case action
+        when :load_content
+          load_content_action if alive?
+        when :register_document
+          register_document_action if content_loaded?
+        when :load_document
+          load_document_action if documents_registered?
         else
-          puts 'unknown'
+          log.warn "Action: '#{action}' is invalid for status: '#{status}'"
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def fire_next_action
+        if alive?
+          fire_action(:load_content)
+        elsif content_loaded?
+          fire_action(:register_document)
+        elsif documents_registered?
+          fire_action(:load_document)
         end
       end
 
@@ -106,60 +158,159 @@ module KManager
       end
 
       def load_content
-        log.warn 'you need to implement load_content'
+        # log.warn 'you need to implement load_content'
       end
 
       def register_document
-        log.warn 'you need to implement register_document'
+        # log.warn 'you need to implement register_document'
+        KManager::Resources::ResourceDocumentFactory.create_documents(self)
       end
 
-      # This might be better off in a factory method
-      # Klue.basic
-      def create_document
-        KManager::Documents::BasicDocument.new(
+      # 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: KManager.opts.exception_style)
+        # log.exception(e, style: :short)
+      end
+      # rubocop:enable Lint/RescueException
+
+      # This is when you need a simple container
+      def new_document(data)
+        document = KDoc::Container.new(
           key: infer_key,
-          type: type,
-          namespace: '',
-          resource: self
+          type: content_type,
+          namespace: namespace,
+          default_data_type: data.class,
+          data: data
         )
+        attach_document(document)
+      end
+
+      def attach_document(document, change_content_type: nil)
+        @content_type = change_content_type if change_content_type
+
+        document.owner = self
+        @documents << document
+        document
       end
 
-      # TODO: Unit Test
-      def attach_document(document, change_resource_type: nil)
-        @type = change_resource_type if change_resource_type
+      def scheme
+        uri&.scheme&.to_sym || default_scheme
+      end
 
-        add_document(document)
+      def host
+        uri&.host
       end
 
-      def load_document
-        log.warn 'you need to implement load_document'
+      # What schema does the underlying resource connect with by default
+      #
+      # Examples:
+      #
+      # :file
+      # :web (http: https: fpt:)
+      # :mem - some type of memory structure
+      def default_scheme
+        :unknown
+      end
+
+      # Optionally overridden, this is the case with FileResource
+      def infer_content_type
+        nil
+      end
+
+      def default_content_type
+        :unknown
+      end
+
+      def alive?
+        @status == :alive
+      end
+
+      def content_loaded?
+        @status == :content_loaded
+      end
+
+      def documents_registered?
+        @status == :documents_registered
+      end
+
+      def documents_loaded?
+        @status == :documents_loaded
+      end
+
+      # Setting the URI can be overridden by WebResource and FileResource
+      def uri=(uri)
+        return if uri.nil?
+
+        @uri = URI(uri) if uri.is_a?(String)
+        @uri = uri      if uri.is_a?(URI)
+
+        # log.kv 'uri type', uri.class
+        # It might be useful to have a Resource Specific Guard being called to warn if the wrong URI type is inferred from here
+        # supported URI::Class (Generic, File, HTTP, HTTPS)
       end
 
       # rubocop:disable Metrics/AbcSize
-      def debug
-        log.section_heading('resource')
-        log.kv 'source'   , source                                                , 15
-        log.kv 'type'     , type                                                  , 15
-        log.kv 'status'   , status                                                , 15
+      def attribute_values(prefix = nil)
+        result = {}
+        result["#{prefix}id".to_sym]              = object_id
+        result["#{prefix}key".to_sym]             = infer_key
+        result["#{prefix}namespace".to_sym]       = namespace
+        result["#{prefix}status".to_sym]          = status
+        result["#{prefix}source".to_sym]          = source_path
+        result["#{prefix}content_type".to_sym]    = content_type
+        result["#{prefix}content".to_sym]         = content
+        result["#{prefix}document_count".to_sym]  = documents.length
+        result["#{prefix}errors".to_sym]          = error_hash
+        result["#{prefix}valid".to_sym]           = valid?
+        result["#{prefix}scheme".to_sym]          = scheme
+        result["#{prefix}host".to_sym]            = host
+        result
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # rubocop:disable Metrics/AbcSize
+      def debug(heading = 'resource')
+        width = 20
+        log.section_heading(heading)
+        log.kv 'area'             , area.name                                             , width if area
+        log.kv 'area namespace'   , area.namespace                                        , width if area
+        log.kv 'scheme'           , scheme                                                , width
+        log.kv 'host'             , host , width
+        log.kv 'source_path'      , source_path                                           , width
+        log.kv 'content_type'     , content_type                                          , width
+        log.kv 'status'           , status                                                , width
+        log.kv 'content'          , content.nil? ? '' : content[0..100].gsub("\n", '\n')  , width
+        log.kv 'documents'        , documents.length                                      , width
+
+        yield if block_given?
+
+        log_any_messages
+
+        # log.kv 'infer_key', infer_key                                             , width
         # log.kv 'project'  , project
-        log.kv 'content'  , content.nil? ? '' : content[0..100].gsub("\n", '\n')  , 15
-        log.kv 'documents', documents.length                                      , 15
 
         documents.each(&:debug)
+        nil
       end
       # rubocop:enable Metrics/AbcSize
 
       private
 
-      def add_document(document)
-        # First document in list goes into .document
-        @documents << document
-        document
+      def value_remove(opts, key)
+        return opts.delete(key) if opts.key?(key)
+
+        nil
       end
 
       def load_content_action
         @status = :content_loading
-        @content = nil
         load_content
         @status = :content_loaded
       end

data/lib/k_manager/resources/file_resource.rb

@@ -2,91 +2,114 @@
 
 module KManager
   module Resources
-    require 'handlebars/helpers/string_formatting/dasherize'
-
-    # A file resource represents context that is loaded via a file.
+    # A file resource represents content that is loaded via a file.
     #
     # File resources have the benefit that file watchers can watch them
-    # locally and reload these resources on change.
+    # locally and reload when these resources on change.
     class FileResource < KManager::Resources::BaseResource
       include KLog::Logging
 
-      # Full path to file
+      KNOWN_EXTENSIONS = {
+        '.rb' => :ruby,
+        '.csv' => :csv,
+        '.json' => :json,
+        '.yaml' => :yaml
+      }.freeze
+
+      def initialize(uri, **opts)
+        warn('URI::File type expected for File Resource') unless uri.is_a?(URI::File)
+        super(uri, **opts)
+        log_any_messages unless valid?
+      end
+
+      # Infer key is the file name without the extension stored in dash-case
+      def infer_key
+        file_name = Pathname.new(source_path).basename.sub_ext('').to_s
+        Handlebars::Helpers::StringFormatting::Snake.new.parse(file_name)
+      end
+
+      def default_scheme
+        :file
+      end
+
+      # Currently in base
+      # def register_document
+      #   KManager::Resources::ResourceDocumentFactory.create_documents(self)
+      # end
+
+      def attribute_values(prefix = nil)
+        result = super(prefix)
+        result["#{prefix}path".to_sym]          = resource_path
+        result["#{prefix}relative_path".to_sym] = resource_relative_path
+        result["#{prefix}exist".to_sym]         = resource_valid?
+        result
+      end
+
+      def debug
+        super do
+          log.kv 'infer_key'        , infer_key , 20
+          log.kv 'file'             , source_path        , 20
+          log.kv 'resource_path'    , resource_path      , 20
+          log.kv 'resource_valid?'  , resource_valid?    , 20
+        end
+      end
+
+      # Source path - aka Full path to file
       #
       # example: /Users/davidcruwys/dev/kgems/k_dsl/spec/factories/dsls/common-auth/admin_user.rb
-      attr_reader :file
+      def source_path
+        uri.path
+      end
 
-      def initialize(**opts)
-        super(**opts)
-        @source = :file
-        @file = opts[:file]
+      # TODO: Write tests
+      def recreate(resource)
+        raise 'Recreate only works for resources of the same type' unless resource.is_a?(self.class)
 
-        guard
+        # area: resource.area,
+        # content_type: resource.content_type,
+        opts = {
+          area: resource.area,
+          namespace: resource.namespace
+        }
+
+        resource.class.new(resource.uri, **opts)
       end
 
-      class << self
-        def instance(**opts)
-          file = opts[:file]
-
-          extension = ::File.extname(file).downcase
-
-          case extension
-          when '.rb'
-            KManager::Resources::RubyFileResource.new(**opts)
-          when '.csv'
-            KManager::Resources::CsvFileResource.new(**opts)
-          when '.json'
-            KManager::Resources::JsonFileResource.new(**opts)
-          when '.yaml'
-            KManager::Resources::YamlFileResource.new(**opts)
-          else
-            KManager::Resources::UnknownFileResource.new(**opts)
-          end
-        end
+      def resource_path
+        @resource_path ||= absolute_path(source_path)
       end
 
-      # Infer key is the file name without the extension stored in dash-case
-      def infer_key
-        file_name = Pathname.new(@file).basename.sub_ext('').to_s
-        Handlebars::Helpers::StringFormatting::Dasherize.new.parse(file_name)
+      def resource_relative_path(from_path = Dir.pwd)
+        Pathname.new(resource_path).relative_path_from(from_path).to_s
       end
 
+      def resource_valid?
+        File.exist?(resource_path)
+      end
+
+      private
+
       def load_content
-        if File.exist?(file)
+        if resource_valid?
           begin
-            @content = File.read(file)
+            @content = File.read(resource_path)
           rescue StandardError => e
             log.error e
           end
         else
-          log.error "Source file not found: #{file}"
+          guard("Source file not found: #{resource_path}")
         end
       end
 
-      def register_document
-        attach_document(create_document)
-      end
+      def absolute_path(path)
+        pn = Pathname(path)
 
-      # rubocop:disable  Metrics/AbcSize
-      def debug
-        log.section_heading('resource')
-        log.kv 'source'   , source                                                , 15
-        log.kv 'file'     , file                                                  , 15
-        log.kv 'type'     , type                                                  , 15
-        log.kv 'infer_key', infer_key                                             , 15
-        log.kv 'status'   , status                                                , 15
-        # log.kv 'project'  , project
-        log.kv 'content'  , content.nil? ? '' : content[0..100].gsub("\n", '\n')  , 15
-        log.kv 'documents', documents.length                                      , 15
-
-        documents.each(&:debug)
+        pn.exist? ? pn.realpath.to_s : File.expand_path(path)
       end
-      # rubocop:enable  Metrics/AbcSize
-
-      private
 
-      def guard
-        raise KType::Error, 'File resource requires a file option' if @file.nil? || @file == ''
+      def infer_content_type
+        extension = ::File.extname(source_path).downcase
+        KNOWN_EXTENSIONS[extension]
       end
     end
   end

data/lib/k_manager/resources/mem_resource.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module KManager
+  module Resources
+    require 'handlebars/helpers/string_formatting/dasherize'
+
+    # A memory resource represents content that is generated programmatically and just stored in memory.
+    class MemResource < KManager::Resources::BaseResource
+      def initialize(**opts)
+        fake_uri = URI.parse("mem://#{SecureRandom.alphanumeric(4)}")
+        super(fake_uri, **opts)
+      end
+    end
+  end
+end

data/lib/k_manager/resources/resource_document_factory.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module KManager
+  module Resources
+    # Create documents based on the target resource
+    #
+    # This factory will lock the resource and then create
+    # new documents based on the content of the resource.
+    #
+    # In the case of a ruby resource, this factory will evaluate the ruby
+    # code dynamically and any ruby file with standard document DSL's will
+    # create additional documents using KManager::DocumentFactory
+    class ResourceDocumentFactory
+      # TODO: The original system always created 1 document, so need to consider if 0-more should become 1-more
+      class << self
+        include KLog::Logging
+        # Build 0-more documents and attach them to the resource.
+        #
+        # The resource is stored in the KManager.current_resource context
+        # and wrapped by a Mutex so that any self registering documents can
+        # figure out which resource to register themselves against
+        def create_documents(target_resource)
+          KManager.for_resource(target_resource) do |resource|
+            process_resource(resource)
+          end
+        end
+
+        private
+
+        # Create 0-Many documents and attach to the resource
+        #
+        # @param [BaseResource] resource The resource that created and is thus owns the document
+        # @param [Symbol] content_type Type of content, %i[csv json yaml ruby unknown]
+        # @param [String] key is the unique resource key
+        # @param [String] content Resource content as a raw string, examples could be CSV, JSON, YAML, RUBY or some other text content
+        def process_resource(resource)
+          case resource.content_type
+          when :csv
+            resource.new_document(process_csv(resource.content))
+          when :json
+            resource.new_document(process_json(resource.content))
+          when :yaml
+            resource.new_document(process_yaml(resource.content))
+          when :ruby
+            process_ruby(resource)
+            :ruby
+          else
+            :unknown
+          end
+        end
+
+        def process_csv(content)
+          rows = []
+
+          CSV.parse(content, headers: true, header_converters: :symbol) do |row|
+            rows << row.to_h
+          end
+          rows
+        rescue StandardError => e
+          log.exception(e, style: :message)
+          []
+        end
+
+        def process_json(content)
+          JSON.parse(content)
+        rescue StandardError => e
+          log.exception(e, style: :message)
+          {}
+        end
+
+        def process_yaml(content)
+          YAML.safe_load(content)
+        rescue StandardError => e
+          log.exception(e, style: :message)
+          {}
+        end
+
+        # rubocop:disable Lint/RescueException
+        def process_ruby(resource)
+          # puts content
+          # KManager::Manager.current_resource
+          # KDsl.target_resource = self
+
+          # log.error "#{resource.activated?} - #{resource.resource_path}"
+
+          Object.class_eval resource.content, resource.resource_path
+
+          # # Only DSL's will add new resource_documents
+          # 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
+          # resource.error = ex
+          resource.guard(e.message)
+          resource.debug
+          log.exception(e, style: :short)
+
+          # L.exception resource.error
+
+          # KDsl.target_resource = nil
+
+          # # A regular ruby file would not add resource_documents
+          # # so create one manually
+          # add_document(new_document) if documents.length === 0
+        end
+        # rubocop:enable Lint/RescueException
+
+        # # TEST REQUIRED
+        # def add_document(document)
+        #   # project.register_dsl(document)
+        #   project.add_resource_document(self, document)
+        #   document.resource = self
+        #   documents << document
+        #   document
+        # end
+      end
+    end
+  end
+end

data/lib/k_manager/resources/resource_factory.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module KManager
+  module Resources
+    class ResourceFactory
+      # TODO: Write tests
+
+      # Create a resource based on a resource URI.
+      #
+      # Resources may be of type File or Web
+      #
+      # The resource content_type should be passed in when it cannot be inferred (e.g. WebResource)
+      # for a FileResource this option is optional and will be inferred from the file extension.
+      def instance(resource_uri, **opts)
+        scheme = resource_uri.scheme.to_sym
+
+        case scheme
+        when :file
+          FileResource.new(resource_uri, **opts)
+        when :http, :https
+          WebResource.new(resource_uri, **opts)
+        else
+          raise 'Unknown schema'
+        end
+      end
+    end
+  end
+end