k_doc 0.0.18 → 0.0.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28959da3b25b7817899193c0b0057e42750783a561e8190de4f6af82be5116c9
-  data.tar.gz: c55996060304324b439d6a02d3a0993279a9f76dee8468802486a9e92cf958e3
+  metadata.gz: a39ec448d9de5183b86d1ee4e4d45cf529db22669bf10567efd9c35151aaf79c
+  data.tar.gz: 5d2388c614eeedec80cc2a1b2a587d94763102983b3ffdf64b04906a7efcc8ea
 SHA512:
-  metadata.gz: e5c7303c8d1d9f0b6b90c1071c46d20852ed7796ba3410e2267f5fc42af55dc9ac7d20ff43d1c9a228f6779b67a1e9da0ecdde0b0fffe42b2b87811571af7d72
-  data.tar.gz: e464b9117c83fdd72fc25a1bb17815ff62cf58a74b6e4f197c070eccf588ecd45e99ca25ff7985b06b1dd889e0fa62c1fd7adffc29c6b3bc2b50870ae13e88eb
+  metadata.gz: 9dd44d107a8b053afadace454dec1b650a9bb92b5f24451ff77dec479000a270904938d925efc9639c10a955c605995b3608465437d46b670c687fd595915564
+  data.tar.gz: b27b655fcd670d9db544f52b2b998fbf7adbbe00572cfec09c3e80d14518a403e1101826197c2d580e55768452c7791c6420f048ecafeeca59e0906ef2d1fbe0

data/.builders/directors/_.rb

@@ -0,0 +1,10 @@
+require_relative './build_actions'
+require_relative './director'
+# require_relative './gem_director'
+require_relative './klue_director'
+require_relative './design_pattern_director'
+
+def klue
+  @klue ||= KlueDirector.new
+end
+

data/.builders/directors/build_actions.rb

@@ -0,0 +1,39 @@
+module BuildActions
+  def cd(folder_key)
+    @builder.cd(folder_key)
+
+    self
+  end
+
+  def add_file(file, **opts)
+    @builder.add_file(file, **opts)
+
+    self
+  end
+
+  def delete_file(file, **opts)
+    @builder.delete_file(file, **opts)
+
+    self
+  end
+
+  def add_clipboard(**opts)
+    @builder.add_clipboard(**opts)
+
+    self
+  end
+
+  def open
+    builder.open
+
+    self
+  end
+  alias o open
+
+  def open_template
+    builder.open_template
+
+    self
+  end
+  alias ot open_template
+end

data/.builders/directors/design_pattern_director.rb

@@ -0,0 +1,39 @@
+class DesignPatternDirector < Director
+  include BuildActions
+
+  def del(file, *_params, **opts)
+    delete_file(file, **opts)
+
+    self
+  end
+  alias dadd del
+
+  def add(output_file, template_file = nil, **opts)
+    template_file = output_file if template_file.nil?
+      
+    opts = {
+      template_file: template_file,
+      on_exist: :write
+    }.merge(opts)
+
+    add_file(output_file, **opts)
+    puts output_file
+
+    self
+  end
+
+  # This pattern would be great as a configurable generic class
+  #
+  # children could be renamed as:
+  # - directors
+  # - components
+  # - elements
+  def composite(name:, relative_path:, **opts)
+    opts = { name: name }.merge(opts)
+    cd(:lib)
+    add(File.join(relative_path, "#{name}.rb"), "composite/composite.rb", **opts)
+    cd(:spec)
+    add(File.join(relative_path, "#{name}_spec.rb"), "composite/composite_spec.rb", **opts)
+    self
+  end
+end

data/.builders/directors/director.rb

@@ -0,0 +1,185 @@
+class Director
+  include KType::Composite
+  # Should this be on the base class, or setup as needed on child directors?
+
+  attr_reader :builder
+
+  # Maybe Deprecate
+  attr_reader :director_types
+
+  def initialize(parent = nil, **opts)
+    attach_parent(parent)
+
+    reset_settings
+    process_options(opts)
+  end
+
+  def init(opts)
+    reset_settings
+    process_options(opts)
+    
+    self
+  rescue => ex
+    log.exception(ex)
+  end
+
+  def reset
+    reset_settings
+
+    self
+  rescue => ex
+    log.exception(ex)
+  end
+
+  def register(name, klass)
+    register_director(name, klass)
+
+    self
+  rescue => ex
+    log.exception(ex)
+  end
+
+  def back
+    navigate_parent
+  end
+
+  def with(director, &block)
+    change_director = director(director)
+    change_director.instance_eval(&block)
+    navigate_parent
+  end
+
+  def help(*topics) #**opts)
+    if topics.blank?
+      help_actions
+      return
+    end
+
+    help_actions          if topics.include?(:all)
+    help_channels         if topics.include?(:channels)
+  rescue => ex
+    log.exception(ex)
+  end
+
+  def director(name)
+    @director ||= Hash.new do |add_to_hash, key|
+      raise "Director not registered: #{key}" unless has_child?(key)
+      director = get_child(key)
+      add_to_hash[key] = director.klass.new(self).init(builder_config_name: key)
+    end
+    @director[name]
+  rescue => ex
+    log.exception(ex)
+  end
+
+  def guard(message)
+    log.error(message)
+
+    self
+  end
+  
+
+  # def director(type, name)
+  #   Setup.config(type).debug
+  # end
+
+  def debug
+    # puts 'debug'
+    # puts children
+    # puts director_types
+    if builder
+      builder.debug
+    else
+      log.error "No builder"
+    end
+
+    director_types.keys.each do |key|
+      log.section_heading(key)
+      log.structure director_types[key]
+    end
+    
+    self
+  end
+
+  private
+
+  # Composite Pattern Custom Implementation - BEGIN
+
+  def has_child?(key)
+    @children.key?(key)
+  end
+
+  def get_child(key)
+    @children[key]
+  end
+
+  def add_child(key, child)
+    @children[key] = child
+  end
+
+  def reset_children
+    @children = {}
+  end
+
+  # Composite Pattern Custom Implementation - END
+
+  def register_director(name, klass)
+    if has_child?(name)
+      log.error "Director has already been registered: #{name}"
+      return
+    end
+
+    add_director(name, klass)
+  rescue => ex
+    log.exception(ex)
+  end
+
+  def add_director(name, klass)
+    director = OpenStruct.new(name: name, klass: klass)
+
+    # Adding a director should create a new method for accessing that director
+    add_child(name, director)
+  rescue => ex
+    log.exception(ex)
+  end
+
+  # HELP
+
+  def help_actions
+    log.warn 'Help about actions available from this class'
+  end
+
+  def help_channels
+    log.warn 'Help about channels'
+    debug
+  end
+
+  def reset_settings
+    @builder = nil
+    reset_children
+    @director_types = {}
+  end
+
+  def process_options(opts)
+    attach_builder(opts)
+  rescue => ex
+    log.exception(ex)
+  end
+
+  # If builder is provided then use it
+  # If builder configuration is provided
+  # If builder config_name is provided
+
+  def attach_builder(opts)
+    return if @builder
+
+    log.warning("options :builder and :builder_config_name are mutually exclusive, will use opts[:builder]") if opts[:builder] && opts[:builder_config_name]
+
+    # Use the provided builder
+    @builder = opts[:builder] if opts[:builder]
+
+    return if @builder
+
+    @builder = KBuilder::BaseBuilder.init(KBuilder.configuration(opts[:builder_config_name]))
+  end
+end

data/.builders/directors/klue_director.rb

@@ -0,0 +1,5 @@
+class KlueDirector < Director
+  def design_patterns
+    director(:design_patterns)
+  end
+end

data/.builders/initializers/_.rb

@@ -0,0 +1,7 @@
+require 'k_log'
+require 'k_util'
+
+include KLog::Logging
+
+require_relative './configure_builder'
+require_relative './handlebars_helpers'

data/.builders/initializers/configure_builder.rb

@@ -0,0 +1,38 @@
+KBuilder.reset(:gem)
+KBuilder.configure(:gem) do |config|
+  # config.template_folders.add(:global     , '~/dev/kgems/k_templates/definitions/genesis')
+  config.target_folders.add(:root         , File.expand_path('..', Dir.getwd))
+  config.target_folders.add(:lib          , :root, 'lib', 'k_doc')
+  config.target_folders.add(:spec         , :root, 'spec', 'k_doc')
+end
+
+KBuilder.reset(:design_patterns)
+KBuilder.configure(:design_patterns) do |config|
+  config.template_folders.add(:global     , '~/dev/kgems/k_templates/templates/ruby_design_patterns')
+  config.target_folders.add(:root         , File.expand_path('..', Dir.getwd))
+  config.target_folders.add(:lib          , :root, 'lib', 'k_doc')
+  config.target_folders.add(:spec         , :root, 'spec', 'k_doc')
+end
+
+# KBuilder.configuration(:gem).debug
+
+# def builder
+#   @builder ||= KBuilder::BaseBuilder.init
+# end
+
+puts ':)'
+
+# Setup.configure(:microapp) do |config|
+#   config.template_folders.add(:microapp   , '~/dev/kgems/k_templates/definitions/microapp')
+#   config.target_folders.add(:root         , Dir.getwd)
+# end
+
+# Setup.configure(:data) do |config|
+#   # config.template_folders.add(:microapp   , '~/dev/kgems/k_templates/definitions/microapp')
+#   config.target_folders.add(:root         , File.expand_path('..', Dir.getwd), '.data')
+# end
+
+# Setup.configure(:actual_app) do |config|
+#   # config.template_folders.add(:microapp   , '~/dev/kgems/k_templates/definitions/microapp')
+#   config.target_folders.add(:root         , File.expand_path('..', Dir.getwd))
+# end

data/.builders/initializers/handlebars_helpers.rb

@@ -0,0 +1,27 @@
+Handlebars::Helpers.configure do |config|
+  config_file = File.join(Gem.loaded_specs['handlebars-helpers'].full_gem_path, '.handlebars_helpers.json')
+  config.helper_config_file = config_file
+
+  string_config_file = File.join(Gem.loaded_specs['handlebars-helpers'].full_gem_path, '.handlebars_string_formatters.json')
+  config.string_formatter_config_file = string_config_file
+end
+
+def camel
+  require 'handlebars/helpers/string_formatting/camel'
+  Handlebars::Helpers::StringFormatting::Camel.new
+end
+
+def titleize
+  require 'handlebars/helpers/string_formatting/titleize'
+  Handlebars::Helpers::StringFormatting::Titleize.new
+end
+
+def pluralize
+  require 'handlebars/helpers/inflection/pluralize'
+  Handlebars::Helpers::Inflection::Pluralize.new
+end
+
+def singularize
+  require 'handlebars/helpers/inflection/singularize'
+  Handlebars::Helpers::Inflection::Singularize.new
+end

data/.builders/setup.rb

@@ -0,0 +1,18 @@
+require 'initializers/_'
+require 'directors/_'
+
+klue
+  .reset
+  .register(:design_patterns           , DesignPatternDirector)
+
+klue
+  .with(:design_patterns) do
+    composite(
+      relative_path: 'mixins',
+      name: :composite_spec,
+      namespace: 'KDoc',
+      children_name: :child,
+      children_name_plural: :children)
+  end
+
+puts '...'

data/Guardfile

@@ -19,7 +19,7 @@ group :green_pass_then_cop, halt_on_fail: true do
     # Ruby files
     ruby = dsl.ruby
     dsl.watch_spec_files_for(ruby.lib_files)
-    watch(%r{^lib/k_doc/(.+)\.rb$}) { |m| "spec/unit/#{m[1]}_spec.rb" }
+    watch(%r{^lib/k_doc/**/(.+)\.rb$}) { |m| "spec/unit/#{m[1]}_spec.rb" }
     watch(%r{^lib/k_doc/commands/(.+)\.rb$}) { |m| "spec/unit/commands/#{m[1]}_spec.rb" }
   end
 

data/lib/k_doc/container.rb

@@ -1,50 +1,49 @@
 # frozen_string_literal: true
 
 module KDoc
-  # A data acts a base data object for any data requires tagging such as
-  # unique key, type and namespace.
+  # A container acts a base data object for any data that requires tagging
+  # such as unique key, type and namespace.
   class Container
-    # include KLog::Logging
-
-    # Name of the document (required)
-    #
-    # Examples: user, account, country
-    attr_reader :key
-
-    # Type of data
-    #
-    # Examples by data type
-    #   :csv, :yaml, :json, :xml
-    #
-    # Examples by shape of the data in a DSL
-    #   :entity, :microapp, blueprint
-    attr_reader :type
-
-    attr_writer :data
-
-    attr_reader :error
-
-    # Create container for storing data/documents.
-    #
-    # Any container can be uniquely identified via it's
-    # key, type, namespace and project_key attributes
-    #
-    # @param [Hash] **opts The options
-    # @option opts [String|Symbol] name Name of the container
-    # @option opts [String|Symbol] type Type of the container, defaults to KDoc:: FakeOpinion.new.default_model_type if not set
-    def initialize(**opts)
-      @key = opts[:key] || SecureRandom.alphanumeric(4)
-      @type = opts[:type] || ''
-      @data = opts[:data] || {}
+    include KLog::Logging
+    include KDoc::Guarded
+    include KDoc::Taggable
+    include KDoc::Datum
+    include KDoc::BlockProcessor
+
+    attr_reader :opts
+
+    # TODO: Owner/Owned need to be in a module and tested
+    attr_accessor :owner
+    
+    def owned?
+      @owner != nil
     end
 
-    def debug_header
-      log.kv 'key'  , key   , 15
-      log.kv 'type' , type  , 15
+    def initialize(**opts, &block)
+      @opts = opts
+
+      initialize_tag(opts)
+      initialize_data(opts)
+      initialize_block(opts, &block)
+    end
+
+    def default_container_type
+      :container
+    end
+
+    def default_data_value
+      {}
+    end
+
+    def debug
+      debug_container
+      debug_errors
     end
 
-    def data
-      @data.clone
+    private
+
+    def debug_errors
+      log.block(errors, title: 'errors') unless valid?
     end
   end
 end

data/lib/k_doc/csv_doc.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module KDoc
+  # CsvDoc is a DSL for modeling CSV data objects
+  class CsvDoc < KDoc::Container
+    attr_reader :file
+
+    # Create CSV document
+    #
+    # @param [String|Symbol] name Name of the document
+    # @param args[0] Type of the document, defaults to KDoc:: FakeOpinion.new.default_csv_type if not set
+    # @param default: Default value (using named params), as above
+    def initialize(key = nil, **opts, &block)
+      super(**{ key: key }.merge(opts))
+
+      initialize_file
+
+      @block = block if block_given?
+    end
+
+    # Load data from file
+    #
+    # @param [Symbol] load_action The load_action to take if data has already been loaded
+    # @param [:once] load_action :once will load the data from content source on first try only
+    # @param [:reload] load_action :reload will reload from content source each time
+    # @param [Symbol] data_action The data_action to take when setting data, defaults to :replace
+    # @param [:replace] data_action :replace will replace the existing data instance with the incoming data value
+    # @param [:append] data_action :append will keep existing data and then new value data over the top
+    def load(load_action: :once, data_action: :replace)
+      return if load_action == :once && loaded?
+
+      rows = []
+
+      CSV.foreach(file, headers: true, header_converters: :symbol) do |row|
+        rows << row.to_h
+      end
+
+      set_data(rows, data_action: data_action)
+
+      @loaded = true
+    end
+
+    def loaded?
+      @loaded
+    end
+
+    private
+
+    def initialize_file
+      @file ||= opts.delete(:file) || ''
+      @loaded = false
+    end
+
+    def default_data_value
+      []
+    end
+
+    def default_container_type
+      :csv
+    end
+  end
+end

data/lib/k_doc/fake_opinion.rb

@@ -5,8 +5,12 @@ require 'json'
 module KDoc
   # This is called fake opinion because I have not figured out
   # how I want to implement this
+  # Need to look at the configuration patterns, this is really a configuration
   class FakeOpinion
     attr_accessor :default_model_type
+    attr_accessor :default_csv_type
+    attr_accessor :default_json_type
+    attr_accessor :default_yaml_type
     attr_accessor :default_settings_key
     attr_accessor :default_table_key
 
@@ -16,6 +20,9 @@ module KDoc
 
     def initialize
       @default_model_type = :entity
+      @default_csv_type = :csv
+      @default_json_type = :json
+      @default_yaml_type = :yaml
       @default_settings_key = :settings
       @default_table_key = :table
 

data/lib/k_doc/json_doc.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module KDoc
+  # JsonDoc is a DSL for modeling JSON data objects
+  class JsonDoc < KDoc::Container
+    attr_reader :file
+
+    # Create JSON document
+    #
+    # @param [String|Symbol] name Name of the document
+    # @param args[0] Type of the document, defaults to KDoc:: FakeOpinion.new.default_csv_type if not set
+    # @param default: Default value (using named params), as above
+    # @param [Proc] block The block is stored and accessed different types in the document loading workflow.
+    def initialize(key = nil, **opts, &_block)
+      super(**{ key: key }.merge(opts))
+
+      initialize_file
+    end
+
+    # Load data from file
+    #
+    # @param [Symbol] load_action The load_action to take if data has already been loaded
+    # @param [:once] load_action :once will load the data from content source on first try only
+    # @param [:reload] load_action :reload will reload from content source each time
+    # @param [Symbol] data_action The data_action to take when setting data, defaults to :replace
+    # @param [:replace] data_action :replace will replace the existing data instance with the incoming data value
+    # @param [:append] data_action :append will keep existing data and then new value data over the top
+    def load(load_action: :once, data_action: :replace)
+      return if load_action == :once && loaded?
+
+      content = File.read(file)
+      hash = JSON.parse(content)
+
+      set_data(hash, data_action: data_action)
+
+      @loaded = true
+    end
+
+    def loaded?
+      @loaded
+    end
+
+    private
+
+    def initialize_file
+      @file ||= opts.delete(:file) || ''
+      @loaded = false
+    end
+
+    def default_data_value
+      @default_data_value ||= {}
+    end
+
+    def default_container_type
+      :json
+    end
+  end
+end

data/lib/k_doc/mixins/block_processor.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module KDoc
+  # A container acts a base data object for any data that requires tagging
+  # such as unique key, type and namespace.
+  # Rename: BlockProcessor
+  module BlockProcessor
+    attr_accessor :block
+
+    def initialize_block(_opts, &block)
+      @block = block if block_given?
+    end
+
+    def execute_block(run_actions: nil)
+      eval_block
+      run_on_action if run_actions
+    end
+
+    def eval_block
+      return if @block.nil?
+
+      instance_eval(&@block)
+    rescue StandardError => e
+      log.error('Standard error in document')
+      # puts "key #{unique_key}"
+      # puts "file #{KUtil.data.console_file_hyperlink(resource.file, resource.file)}"
+      log.error(e.message)
+      @error = e
+      raise
+    end
+
+    def run_on_action
+      return if @block.nil?
+
+      on_action if respond_to?(:on_action)
+    rescue StandardError => e
+      log.error('Standard error while running actions')
+      # puts "key #{unique_key}"
+      # puts "file #{KUtil.data.console_file_hyperlink(resource.file, resource.file)}"
+      log.error(e.message)
+      @error = e
+      raise
+    end
+  end
+end