k_manager 0.0.13 → 0.0.22

data/lib/k_manager/resources/resource_manager.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module KManager
+  # TODO: Write tests
+
+  # Usage1:
+  #   manager = ResourceManager.new
+  #   manager.add_resource('file:///david.csv')
+  #   manager.add_resource('file:///david.txt', content_type: :json)
+  #   manager.add_resource('https://gist.github.com/12345/david.csv', content_type: :csv)
+  #   manager.load_resource_content
+  #
+  # Usage2:
+  #   manager = ResourceManager.new
+  #   manager.fileset.add('**/*.csv').add('**/*.json').add('lib/*.rb')
+  #   manager.add_resources
+  #   manager.load_resource_content
+  #
+  #
+  # Usage KWatcher
+  # WatchingDirctory('abc') do |path|
+  #   manager.update_resource(path)
+  # end
+
+  # Example Director
+  # KDoc.diagram(:k_resource) do
+
+  #   component(:resource_manager) do
+  #     attr_rw(:resources)
+  #     attr_rw(:fileset)
+
+  #     method(:add_resource, description: "I will add a resource to the manager") do
+  #       param(:resource_uri, description: 'xxxx')
+  #     end
+
+  #     method(:add_resource, description: "I will add a collection of resources to the manager via fileset or webset")
+  #     method(:load_resource_content)
+  #   end
+
+  #   def on_action
+  #     build_drawio("#{self.name}_class"       , model: self.data, style: :class_diagram)
+  #     build_drawio("#{self.name}_component"   , model: self.data, style: :component_diagram)
+  #     build_drawio("#{self.name}_swim"        , model: self.data, style: :swimlane_diagram)
+  #   end
+  # end
+
+  module Resources
+    class ResourceManager
+      extend Forwardable
+
+      include KLog::Logging
+      include KDoc::Guarded
+
+      attr_accessor :area
+
+      attr_accessor :fileset
+      attr_accessor :webset
+      attr_accessor :memset
+
+      # Resource set is built using file, web and memory resources
+      attr_accessor :resource_set
+
+      def initialize(area)
+        @area             = area
+
+        @fileset          = KFileset::FileSet.new
+        @webset           = nil # TODO: when ready to implement URL based resources
+        @memset           = nil # TODO: when ready to implement dynamic memory resources
+
+        @resource_factory = KManager::Resources::ResourceFactory.new
+        @resource_set     = KManager::Resources::ResourceSet.new(area)
+      end
+
+      def_delegators :resource_set, :resources, :find_by_uri
+
+      # def resources
+      #   resource_set.resources
+      # end
+
+      def resource_models
+        resource_set.resources.map(&:as_model)
+      end
+
+      def resource_changed(resource_uri, state)
+        create_resource(resource_uri) if state == :created
+        update_resource(resource_uri) if state == :updated
+        delete_resource(resource_uri) if state == :deleted
+
+        log_any_messages unless valid?
+      end
+
+      def create_resource(resource_uri)
+        # TODO: skip if not whitelisted
+
+        # warn if the resource already existed (this should not happen)
+        # if fileset.whitelist
+        # build resource
+        # add resource to fileset
+      end
+
+      def update_resource(resource_uri)
+        # TODO: skip if not whitelisted
+
+        resource = resource_set.find_by_uri(resource_uri)
+
+        return warn("Resource not in Resource Set - Skipping: #{resource_uri.path}") unless resource
+
+        replace_resource = resource.recreate(resource)
+        replace_resource.fire_action(:load_content)
+        replace_resource.fire_action(:register_document)
+        replace_resource.fire_action(:load_document)
+        resource_set.replace(replace_resource)
+      end
+
+      def delete_resource(resource_uri)
+        # TODO: skip if not whitelisted
+
+        # find resource
+        # if found, remove it
+      end
+
+      def add_resource_expand_path(file, **opts)
+        add_resource(File.expand_path(file), **opts)
+      end
+
+      # Add a resource based on a resource_uri
+      #
+      # @param [URI|String] resource_uri Path to the resource, if the path uses file:/// then it will add a file resource, if the path http: or https: then a web resource will be added
+      # TODO: Test File URI: relative_path
+      # TODO: Test File URI: absolute_path
+      # TODO: Test URI
+      # TODO: Test URI (Web)
+      # TODO: Test URI (File)
+      def add_resource(resource_uri, **opts)
+        resource_set.add(build_resource(resource_uri, **opts))
+      end
+
+      # TODO: Not sure if this is right
+      def build_resource(resource_uri, **opts)
+        resource_uri = parse_uri(resource_uri)
+        @resource_factory.instance(resource_uri, **opts)
+      end
+
+      def add_resources
+        add_web_resources
+        add_file_resources
+      end
+
+      # def update_resource(path)
+      #   uri = path_to_uri(path)
+      #   reset_existing_resource(uri)
+      #   add_resource(uri)
+      #   load_resource_content
+      # end
+
+      # Fire actions against all resources in this manager.
+      #
+      # @param [*Array<Symbol>] actions List of actions to run. [:load_content, :register_document, :load_document]
+      def fire_actions(*actions)
+        guard_action(actions)
+
+        load_content        if actions.include?(:load_content)
+        register_documents  if actions.include?(:register_document)
+        load_documents      if actions.include?(:load_document)
+      end
+
+      def guard_action(actions)
+        actions.each do |action|
+          warn "ResourceManager.fire_actions - unknown action: #{action}" unless KManager::Resources::BaseResource.valid_action?(action)
+        end
+      end
+
+      def load_content
+        resources.each do |resource|
+          resource.fire_action(:load_content)
+        end
+      end
+
+      def register_documents
+        resources.each do |resource|
+          resource.fire_action(:register_document)
+        end
+      end
+
+      def load_documents
+        resources.each do |resource|
+          resource.fire_action(:load_document)
+        end
+      end
+
+      def debug
+        resources.each(&:debug)
+      end
+
+      private
+
+      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
+
+        URI.join('file:///', uri)
+      end
+
+      def add_web_resources
+        # TODO
+        # return if @webset.nil?
+      end
+
+      def add_file_resources
+        fileset.path_entries.each do |path_entry|
+          add_resource(path_entry.uri)
+        end
+      end
+    end
+  end
+end

data/lib/k_manager/resources/resource_set.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module KManager
+  # TODO: Write Tests
+
+  # A resource set holds a list of resources
+  #
+  # A resource could be a file, web-service, gist, ftp endpoint, memory object.
+  #
+  # ResourceSet is an internal component and is used by the ResourceManager
+  #
+  # The resource manager will create resources with the ResourceFactory and assign
+  # those resources to the ResourceSet
+  #
+  # The only supported resource types so far are:
+  #  - File
+  #
+  # Resources can be registered with the ResourceSet using register_* methods
+  #
+  # somepath
+  # somepath/my_dsls
+  # somepath/my_dsls/path1
+  # somepath/my_dsls/path2
+  # somepath/my_dsls/path2/child
+  # somepath/my_dsls/path2/old        (skip this path)
+  # somepath/my_data/
+  # somepath/my_templates
+  module Resources
+    class ResourceSet
+      include KLog::Logging
+
+      attr_reader :area
+      attr_reader :resources
+
+      def initialize(area)
+        @area = area
+        @resources = []
+      end
+
+      def add(resource)
+        return log.warn "Resource already added: #{resource.resource_path}" if find(resource)
+
+        resource.area = area
+        resources << resource
+        resource
+      end
+
+      def replace(resource)
+        index = find_index(resource)
+        return log.warn "Resource to replace does not exist: #{resource.resource_path}" unless index
+
+        resource.area = area
+        resources[index] = resource
+        resource
+      end
+
+      def add_resources(resource_list)
+        resource_list.each do |resource|
+          add(resource)
+        end
+      end
+
+      def debug
+        resources.each(&:debug)
+        nil
+      end
+
+      def find_by_uri(resource_uri)
+        resources.find { |r| r.resource_path == resource_uri.path }
+      end
+
+      private
+
+      def find(resource)
+        index = find_index(resource)
+        return nil unless index
+
+        resources[index] # .find { |r| r.resource_path == resource.resource_path }
+      end
+
+      def find_index(resource)
+        resources.index { |r| r.resource_path == resource.resource_path }
+      end
+
+      # def to_h
+      #   resources.map(&:to_h)
+      # end
+    end
+  end
+end

data/lib/k_manager/resources/web_resource.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module KManager
+  module Resources
+    require 'handlebars/helpers/string_formatting/dasherize'
+
+    # A web resource represents content that is loaded via a web URI.
+    #
+    # Web resources do not support watchers and so if you want to handle
+    # content changes then you will either need to poll the resource periodically
+    # or have a server with open channel for web-hooks.
+    class WebResource < KManager::Resources::BaseResource
+      include KLog::Logging
+
+      def initialize(uri, **opts)
+        warn('URI::HTTP/HTTPS type is expected for Web Resource') unless uri.is_a?(URI::HTTP)
+        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
+        last_segment = uri.path.split('/').last
+        Handlebars::Helpers::StringFormatting::Snake.new.parse(last_segment)
+      end
+
+      def default_scheme
+        :https
+      end
+
+      def resource_path
+        @resource_path ||= source_path
+      end
+
+      def resource_relative_path
+        uri.path
+      end
+
+      def resource_valid?
+        return @resource_valid if defined? @resource_valid
+
+        @resource_valid = url_exist?(source_path)
+      end
+
+      def load_content
+        if resource_valid?
+          begin
+            @content = fetch(source_path)
+          rescue StandardError => e
+            log.error e
+          end
+        else
+          guard("Source url not valid: #{resource_path}")
+        end
+      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 'url'              , source_path       , 20
+          log.kv 'resource_path'    , resource_path     , 20
+          log.kv 'resource_valid?'  , resource_valid?   , 20
+        end
+      end
+
+      private
+
+      # rubocop:disable  Metrics/AbcSize
+      def url_exist?(url_str, limit = 10)
+        raise ArgumentError, 'too many HTTP redirects' if limit.zero?
+
+        url = URI.parse(url_str)
+        req = Net::HTTP.new(url.host, url.port)
+        req.use_ssl = (url.scheme == 'https')
+        res = req.request_head(url.path || '/')
+        if res.is_a?(Net::HTTPRedirection)
+          url_exist?(res['location'], limit - 1) # Go after any redirect and make sure you can access the redirected URL
+        else
+          !%w[4 5].include?(res.code[0]) # Not from 4xx or 5xx families
+        end
+      rescue Errno::ENOENT
+        false # false if can't find the server
+      end
+      # rubocop:enable  Metrics/AbcSize
+
+      def fetch(url_str, limit = 10)
+        raise ArgumentError, 'too many HTTP redirects' if limit.zero?
+
+        url = URI.parse(url_str)
+        res = Net::HTTP.get_response(url)
+
+        case res
+        when Net::HTTPSuccess
+          res.body
+        when Net::HTTPRedirection
+          location = res['location']
+          puts "redirected to #{location}"
+          fetch(location, limit - 1)
+        else
+          res.value
+        end
+      end
+    end
+  end
+end

data/lib/k_manager/version.rb

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

data/lib/k_manager/watcher.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'filewatcher'
+require 'io/console'
+
+module KManager
+  # NOTE: Does Watcher belong in this GEM?
+  class Watcher
+    include KLog::Logging
+  
+    attr_reader :watch_folder
+    attr_reader :boot_file
+  
+    def initialize(watch_folder, boot_file)
+      @watch_folder = watch_folder
+      @boot_file = boot_file
+    end
+
+    # process_created_file(filename) if event == :created
+    # process_updated_file(filename) if event == :updated # || event == :created
+    # process_deleted_file(filename) if event == :deleted
+
+    # rubocop:disable Lint/RescueException
+    def start
+      bootup
+
+      update_dashboard
+
+      Filewatcher.new(watch_folder).watch do |changes|
+        changes.each do |filename, event|
+          clear_screen
+
+          puts "File #{event}: #{filename}"
+  
+          uri = URI::File.build(host: nil, path: filename)
+          KManager.resource_changed(uri, event)
+  
+          update_dashboard
+        end
+      end
+    rescue Exception => e
+      # TODO: Make style a setting: :message, :short, (whatever the last one is)
+      log.exception(e, style: :short)
+    end
+    # rubocop:enable Lint/RescueException
+  
+    private
+  
+    def bootup
+      clear_screen
+  
+      content = File.read(boot_file)
+      Object.class_eval(content, boot_file)
+    end
+  
+    def update_dashboard
+      dashboard = KManager::Overview::Dashboard.new(KManager.manager)
+      # dashboard.areas
+      dashboard.resources
+      dashboard.documents
+    end
+  
+    def update_load_path(filename)
+      dirname = File.dirname(filename)
+  
+      # This needs to be in detailed logging
+      $LOAD_PATH.unshift(dirname) unless $LOAD_PATH.find { |path| path.start_with?(dirname) }
+    end
+  
+    def clear_screen
+      puts "\n" * 70
+      $stdout.clear_screen
+    end
+  end
+end

data/lib/k_manager.rb

@@ -1,44 +1,117 @@
 # frozen_string_literal: true
 
+require 'csv'
+require 'dry-struct'
+require 'forwardable'
+require 'k_log'
 require 'k_doc'
+require 'k_fileset'
 require 'k_builder'
 require 'k_ext/github'
-require 'k_log'
 
-require 'k_manager/create_document'
+# IS THIS NEEDED? this was used for infer_key
+require 'handlebars/helpers/string_formatting/dasherize'
+require 'handlebars/helpers/string_formatting/snake'
+
 require 'k_manager/version'
 require 'k_manager/configuration/project_config'
-require 'k_manager/documents/document_taggable'
-require 'k_manager/documents/basic_document'
-require 'k_manager/documents/model_document'
-require 'k_manager/documents/builder_document'
+require 'k_manager/overview/models'
+require 'k_manager/overview/queries'
+require 'k_manager/overview/dump_json'
+require 'k_manager/overview/dashboard'
+require 'k_manager/resources/resource_set'
 require 'k_manager/resources/base_resource'
 require 'k_manager/resources/file_resource'
-require 'k_manager/resources/csv_file_resource'
-require 'k_manager/resources/json_file_resource'
-require 'k_manager/resources/ruby_file_resource'
-require 'k_manager/resources/yaml_file_resource'
-require 'k_manager/resources/unknown_file_resource'
-require 'k_manager/project'
+require 'k_manager/resources/web_resource'
+require 'k_manager/resources/mem_resource'
+require 'k_manager/resources/resource_document_factory'
+require 'k_manager/resources/resource_factory'
+require 'k_manager/resources/resource_manager'
+require 'k_manager/document_factory'
+require 'k_manager/manager'
+require 'k_manager/area'
 
 module KManager
-  extend CreateDocument
-
   # raise KManager::Error, 'Sample message'
   class Error < StandardError; end
 
   class << self
+    extend Forwardable
+
+    # ----------------------------------------------------------------------
+    # Concurrency management for currently 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
+
+    # ----------------------------------------------------------------------
+    # Debug Flags
+    # ----------------------------------------------------------------------
+
+    def debug_state
+      return @debug_state if defined? @debug_state
+
+      @debug_state = :disabled
+    end
+
+    def debug_enable
+      @debug_state = :enabled
+    end
+
+    def debug?
+      debug_state == :enabled
+    end
+
+    # ----------------------------------------------------------------------
+    # Manager facade methods
+    # ----------------------------------------------------------------------
+
+    def manager
+      @manager ||= Manager.new
+    end
+
+    def reset
+      # @resource_mutex.unlock if @resource_mutex
+      # @current_resource = nil
+      @manager = Manager.new
+    end
+
+    def_delegators :manager, :areas, :add_area, :fire_actions, :resource_changed
+
+    # ----------------------------------------------------------------------
+    # Document factory facade methods
+    # ----------------------------------------------------------------------
+
+    def document_factory
+      @document_factory ||= DocumentFactory.new
+    end
+
+    def_delegators :document_factory, :model, :csv, :json, :yaml
+
+    # TODO: DEPRECATE or REFACTOR
     def new_project_config(&block)
       config = KManager::Configuration::ProjectConfig.new
       block.call(config) if block_given?
       config
     end
-
-    # Instance of the currently focused resource
-    # if document get created dynamically due to class_eval then they
-    # can attach themselves to the currently focussed resource via
-    # KManager.target_resource.add_document(document)
-    attr_accessor :target_resource
   end
 end