k_manager 0.0.13

data/lib/k_manager/resources/base_resource.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module KManager
+  module Resources
+    # A resource represents text based content in the project. The content
+    # maybe data, interpreted ruby code or a combination of the two.
+    #
+    # 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.
+    #
+    # Resources can hold different types of static and smart content.
+    # Examples of static content include JSON, YAML and CSV
+    # Example of smart content include Ruby classes, PORO's and DSL's.
+    #
+    # NOTE: The resource represents the text content, but not the actual data or
+    # code that resides there. Instead a document is created to store the data or
+    # code. The reason for this is that some content files, especially DSL's may
+    # have more then one interpreted ruby structure included in the content and so
+    # a document gets created for each DSL, but for all other files, there is
+    # generally only one document.
+    class BaseResource
+      include KLog::Logging
+
+      # Status of the resource
+      # - :initialized
+      # - :content_loading
+      # - :content_loaded
+      # - :documents_registering
+      # - :documents_registered
+      # - :documents_loading
+      # - :documents_loaded
+      attr_reader :status
+
+      # Where is the source of content
+      #
+      # Implement in child classes, examples: :file, :uri, :dynamic
+      attr_reader :source
+
+      # Where is the type of the
+      #
+      # Implement in child classes, examples: :csv, :json, :ruby, :dsl, :yaml
+      attr_reader :type
+
+      attr_reader :project
+
+      # Content of resource, use read content to load this property
+      attr_reader :content
+
+      # List of documents derived from this resource
+      #
+      # Most resources will create one document, but a DSL can generate
+      # multiple documents and some future resources may do as well
+      #
+      # Currently there will always be a minimum of 1 document even if the resource
+      # is not a data resource, e.g. Ruby class
+      attr_accessor :documents
+
+      # Initialize base for resources
+      #
+      # @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
+
+        attach_project(opts[:project]) if opts[:project]
+        @documents = []
+      end
+
+      def attach_project(project)
+        @project = project
+        @project.add_resource(self)
+        self
+      end
+
+      def document
+        @document ||= documents&.first
+      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
+      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
+        else
+          puts 'unknown'
+        end
+      end
+
+      # What identifying key does this resource have?
+      #
+      # Child resources will have different ways of working this out,
+      # eg. File Resources will use the file name.
+      def infer_key
+        nil
+      end
+
+      def load_content
+        log.warn 'you need to implement load_content'
+      end
+
+      def register_document
+        log.warn 'you need to implement register_document'
+      end
+
+      # This might be better off in a factory method
+      # Klue.basic
+      def create_document
+        KManager::Documents::BasicDocument.new(
+          key: infer_key,
+          type: type,
+          namespace: '',
+          resource: self
+        )
+      end
+
+      # TODO: Unit Test
+      def attach_document(document, change_resource_type: nil)
+        @type = change_resource_type if change_resource_type
+
+        add_document(document)
+      end
+
+      def load_document
+        log.warn 'you need to implement load_document'
+      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
+        # 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)
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      private
+
+      def add_document(document)
+        # First document in list goes into .document
+        @documents << document
+        document
+      end
+
+      def load_content_action
+        @status = :content_loading
+        @content = nil
+        load_content
+        @status = :content_loaded
+      end
+
+      def register_document_action
+        @status = :documents_registering
+        register_document
+        # document_factory.create_documents
+        @status = :documents_registered
+      end
+
+      def load_document_action
+        @status = :documents_loading
+        load_document
+        # document_factory.parse_content
+        @status = :documents_loaded
+      end
+    end
+  end
+end

data/lib/k_manager/resources/csv_file_resource.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module KManager
+  module Resources
+    # Represents a CSV file resource.
+    class CsvFileResource < KManager::Resources::FileResource
+      def initialize(**opts)
+        super(**opts)
+        @type = :csv
+      end
+
+      def load_document
+        data = []
+        CSV.parse(content, headers: true, header_converters: :symbol).each do |row|
+          data << row.to_h
+        end
+        document.data = data
+      end
+
+      # def debug
+      #   tp self.document.data, self.document.data.first.to_h.keys
+      # end
+    end
+  end
+end

data/lib/k_manager/resources/factories/document_factory.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+# # frozen_string_literal: true
+# require 'csv'
+
+# module KDsl
+#   module Resources
+#     module Factories
+#       # Base factory for creationg resource_documents
+#       # Tightly coupled to the resource using polymorphic composition
+#       # Something WRONG, should this be a module include instead of a Forwardable Class?
+#       class DocumentFactory
+#         extend Forwardable
+
+#         attr_reader :resource
+
+#         def_delegator :resource, :project
+#         def_delegator :resource, :content
+#         def_delegator :resource, :documents
+#         def_delegator :resource, :new_document
+#         def_delegator :resource, :add_document
+#         def_delegator :resource, :infer_document_key
+#         def_delegator :resource, :infer_document_type
+#         def_delegator :resource, :infer_document_namespace
+
+#         def initialize(resource, resource_type)
+#           @resource = resource
+#           resource.resource_type = resource_type
+#         end
+
+#         def self.instance(resource, source, file)
+#           if source === KDsl::Resources::Resource::SOURCE_FILE
+#             extension = File.extname(file).downcase
+
+#             case extension
+#             when '.rb'
+#               return KDsl::Resources::Factories::RubyDocumentFactory.new(resource)
+#             when '.csv'
+#               return KDsl::Resources::Factories::CsvDocumentFactory.new(resource)
+#             when '.json'
+#               return KDsl::Resources::Factories::JsonDocumentFactory.new(resource)
+#             when '.yaml'
+#               return KDsl::Resources::Factories::YamlDocumentFactory.new(resource)
+#             end
+#           end
+
+#           return KDsl::Resources::Factories::UnknownDocumentFactory.new(resource)
+#         end
+
+#       end
+#     end
+#   end
+# end

data/lib/k_manager/resources/factories/ruby_document_factory.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+# # frozen_string_literal: true
+# require 'csv'
+
+# module KDsl
+#   module Resources
+#     module Factories
+#       # Ruby RubyDocumentFactory can handle Ruby to produce a document
+#       # or KlueDSL content to produce one or more documents
+#       class RubyDocumentFactory < DocumentFactory
+#         def initialize(resource)
+#           super(resource, KDsl::Resources::Resource::TYPE_RUBY)
+#         end
+
+#         def create_documents
+#           KDsl.target_resource = self
+
+#           Object.class_eval content
+
+#           # Only DSL's will add new resource_documents
+#           if documents.length > 0
+#             resource.resource_type = KDsl::Resources::Resource::TYPE_RUBY_DSL
+#           end
+
+#         rescue => exeption
+#           # 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 = exeption
+
+#           L.exception resource.error
+#         ensure
+#           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
+
+#         def parse_content
+#           if self.resource.resource_type === KDsl::Resources::Resource::TYPE_RUBY_DSL
+#             documents.each do |document|
+#               begin
+#                 document.execute_block
+#               rescue => exeption
+#                 # Report the error but still add the document so that you can see
+#                 # it in the ResourceDocument list, it will be marked as Error
+#                 document.error = exeption
+
+#                 L.exception @error
+#               end
+#             end
+#           end
+#         end
+#       end
+#     end
+#   end
+# end

data/lib/k_manager/resources/file_resource.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module KManager
+  module Resources
+    require 'handlebars/helpers/string_formatting/dasherize'
+
+    # A file resource represents context that is loaded via a file.
+    #
+    # File resources have the benefit that file watchers can watch them
+    # locally and reload these resources on change.
+    class FileResource < KManager::Resources::BaseResource
+      include KLog::Logging
+
+      # Full path to file
+      #
+      # example: /Users/davidcruwys/dev/kgems/k_dsl/spec/factories/dsls/common-auth/admin_user.rb
+      attr_reader :file
+
+      def initialize(**opts)
+        super(**opts)
+        @source = :file
+        @file = opts[:file]
+
+        guard
+      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
+      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)
+      end
+
+      def load_content
+        if File.exist?(file)
+          begin
+            @content = File.read(file)
+          rescue StandardError => e
+            log.error e
+          end
+        else
+          log.error "Source file not found: #{file}"
+        end
+      end
+
+      def register_document
+        attach_document(create_document)
+      end
+
+      # 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)
+      end
+      # rubocop:enable  Metrics/AbcSize
+
+      private
+
+      def guard
+        raise KType::Error, 'File resource requires a file option' if @file.nil? || @file == ''
+      end
+    end
+  end
+end

data/lib/k_manager/resources/json_file_resource.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module KManager
+  module Resources
+    # Represents a JSON file resource.
+    class JsonFileResource < KManager::Resources::FileResource
+      def initialize(**opts)
+        super(**opts)
+        @type = :json
+      end
+
+      def load_document
+        data = JSON.parse(content)
+        document.data = data
+      end
+
+      # def debug
+      #   L.ostruct(KDsl::Util.data.to_struct(self.document.data))
+      # end
+    end
+  end
+end

data/lib/k_manager/resources/ruby_file_resource.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module KManager
+  module Resources
+    # Represents a Ruby file resource.
+    class RubyFileResource < KManager::Resources::FileResource
+      def initialize(**opts)
+        super(**opts)
+        @type = :ruby
+      end
+
+      def register_document
+        KManager.target_resource = self
+
+        Object.class_eval content
+
+      # rescue StandardError => exception
+      #   # 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 = exception
+
+      #   L.exception resource.error
+      ensure
+        KManager.target_resource = nil
+
+        # A regular ruby file would not add resource_documents
+        # so create one manually
+        @document = super if documents.length.zero?
+      end
+    end
+  end
+end