k_doc 0.0.5 → 0.0.11

data/lib/k_doc/decorators/settings_decorator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# This could move into KDecor
+module KDoc
+  module Decorators
+    class SettingsDecorator < KDecor::BaseDecorator
+      def initialize
+        super(KDoc::Settings)
+      end
+
+      # def update(target, behaviour)
+      #   update_settings(target, target.internal_data) if %i[all default].include?(behaviour)
+
+      #   target
+      # end
+
+      # # What responsibility will this SettingsDecorator take on?
+      # def update(target, **_opts)
+      #   def update_settings(_target, _settings)
+      #   log.warn('Override this method in your descendant implementation')
+      # end
+    end
+  end
+end

data/lib/k_doc/decorators/table_decorator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module KDoc
+  module Decorators
+    class TableDecorator < KDecor::BaseDecorator
+      def initialize
+        super(KDoc::Table)
+
+        self.implemented_behaviours = %i[update_fields update_rows]
+      end
+
+      def update(target, **opts)
+        behaviour = opts[:behaviour]
+
+        update_fields(target, target.get_fields)  if %i[all update_fields].include?(behaviour)
+        update_rows(target, target.get_rows)      if %i[all update_rows].include?(behaviour)
+
+        target
+      end
+
+      # What responsibility will this TableDecorator take on?
+      # Update fields/columns, or/and
+      def update_fields(_target, _fields)
+        raise KType::Error, 'Update fields not implement, you need to implement this method and '
+      end
+
+      # Update row values/structure
+      def update_rows(_target, _rows); end
+    end
+  end
+end

data/lib/k_doc/fake_opinion.rb

@@ -10,7 +10,7 @@ module KDoc
     attr_accessor :default_settings_key
     attr_accessor :default_table_key
 
-    attr_accessor :document_class
+    # attr_accessor :document_class
     attr_accessor :settings_class
     attr_accessor :table_class
 
@@ -19,7 +19,7 @@ module KDoc
       @default_settings_key = :settings
       @default_table_key = :table
 
-      @document_class = KDoc::Document
+      # @document_class = KDoc::Document
       @table_class = KDoc::Table
       @settings_class = KDoc::Settings
     end

data/lib/k_doc/settings.rb

@@ -6,8 +6,12 @@ module KDoc
   # Builds up key/value settings from the block
   # and applies them to a key coded node on the hash
   class Settings
+    include KLog::Logging
+    # include KDoc::Decorators
+
     attr_reader :parent
     attr_reader :key
+    attr_reader :decorators
 
     alias kp parent
 
@@ -17,6 +21,9 @@ module KDoc
       # Need a way to find out the line number for errors and report it correctly
       begin
         instance_eval(&block) if block_given?
+
+        run_decorators
+
         # rubocop:disable Style/RescueStandardError
       rescue => e
         # rubocop:enable Style/RescueStandardError
@@ -26,27 +33,19 @@ module KDoc
       end
     end
 
-    def my_data
+    # Return these settings which are attached to a data container using :key
+    # internal_data is a bad name, but it is unlikely to interfere with any setting names
+    # Maybe I rename this to raw_data
+    def internal_data
       @data[@key]
     end
 
-    # def run_decorators(opts)
-    #   decorators = KDoc::Decorator.decorate.decorators(opts[:decorators])
-
-    #   return if decorators.empty?
-
-    #   decorators.each do |decorator|
-    #     decorator.send(:update, my_data) if decorator.respond_to?(:update)
-    #     decorator.send(:call, my_data) if decorator.respond_to?(:call)
-    #   end
-    # end
-
     def respond_to_missing?(name, *_args, &_block)
       # puts 'respond_to_missing?'
       # puts "respond_to_missing: #{name}"
       n = name.to_s
       n = n[0..-2] if n.end_with?('=')
-      my_data.key?(n.to_s) || (!@parent.nil? && @parent.respond_to?(name, true)) || super
+      internal_data.key?(n.to_s) || (!@parent.nil? && @parent.respond_to?(name, true)) || super
     end
 
     # rubocop:disable Metrics/AbcSize
@@ -73,14 +72,14 @@ module KDoc
     # object.my_name
     # object.my_name('david')
     def add_getter_or_param_method(name)
-      # L.progress(1, 'add_getter_or_param_method')
+      # log.progress(1, 'add_getter_or_param_method')
       self.class.class_eval do
-        # L.progress(2, 'add_getter_or_param_method')
+        # log.progress(2, 'add_getter_or_param_method')
         name = name.to_s.gsub(/=$/, '')
-        # L.progress(3, 'add_getter_or_param_method')
+        # log.progress(3, 'add_getter_or_param_method')
         define_method(name) do |*args|
-          # L.progress(4, 'add_getter_or_param_method')
-          # L.kv 'add_getter_or_param_method', name
+          # log.progress(4, 'add_getter_or_param_method')
+          # log.kv 'add_getter_or_param_method', name
           raise KDoc::Error, 'Multiple setting values is not supported' if args.length > 1
 
           if args.length.zero?
@@ -95,35 +94,48 @@ module KDoc
     # Handles Setter method
     # object.my_name = 'david'
     def add_setter_method(name)
-      # L.progress(1, 'add_setter_method')
+      # log.progress(1, 'add_setter_method')
       self.class.class_eval do
-        # L.progress(2, 'add_setter_method')
+        # log.progress(2, 'add_setter_method')
         name = name.to_s.gsub(/=$/, '')
-        # L.progress(3, 'add_setter_method')
-        # L.kv 'add_setter_method', name
+        # log.progress(3, 'add_setter_method')
+        # log.kv 'add_setter_method', name
         define_method("#{name}=") do |value|
-          # L.progress(4, 'add_setter_method')
-          # L.kv 'value', value
-          my_data[name.to_s] = value
+          # log.progress(4, 'add_setter_method')
+          # log.kv 'value', value
+          internal_data[name.to_s] = value
         end
       end
     end
 
     def get_value(name)
-      my_data[name.to_s]
+      internal_data[name.to_s]
     end
 
     def debug
-      puts JSON.pretty_generate(my_data)
+      puts JSON.pretty_generate(internal_data)
     end
 
     private
 
+    # This method can move into decorator helpers
+    def run_decorators
+      decorators.each { |decorator| decorator.decorate(self, :settings) }
+    end
+
     def initialize_attributes(data, key = nil, **options)
       @data = data
       @key = (key || FakeOpinion.new.default_settings_key).to_s
 
-      @parent = options[:parent] if !options.nil? && options.key?(:parent)
+      @parent = options[:parent] if options.key?(:parent)
+
+      decorator_list = options[:decorators].nil? ? [] : options[:decorators]
+
+      # This code needs to work differently, it needs to support the 3 different types
+      # Move the query into helpers
+      @decorators = decorator_list
+                    .map(&:new)
+                    .select { |decorator| decorator.compatible?(self) }
 
       @data[@key] = {}
     end

data/lib/k_doc/table.rb

@@ -3,16 +3,33 @@
 module KDoc
   # Build rows (aka DataTable) with field definitions and rows of data
   class Table
+    include KLog::Logging
+
     attr_reader :parent
     attr_reader :name
+    attr_reader :decorators
 
     def initialize(data, name = nil, **options, &block)
       initialize_attributes(data, name, **options)
 
+      @has_executed_field_decorators = false
+      @has_executed_row_decorators = false
+
       instance_eval(&block) if block_given?
+
+      run_decorators(:update_rows)
     end
 
-    def fields(field_definitions)
+    # Pass fields in using the following format
+    #   fields :name, f(:type, :string), :db_type
+    #
+    # The older format of an array is supported via a splat conversion
+    def fields(*field_definitions)
+      if field_definitions.length == 1 && field_definitions[0].is_a?(Array)
+        log.warn('avoid supplying field definitions with array. *Splat fields is the preferred technique.')
+        field_definitions = *field_definitions[0]
+      end
+
       fields = @data[@name]['fields']
 
       field_definitions.each do |fd|
@@ -22,15 +39,18 @@ module KDoc
                     fd
                   end
       end
+
+      run_decorators(:update_fields)
     end
 
     # rubocop:disable Metrics/AbcSize
     def row(*args, **named_args)
       fields = @data[@name]['fields']
 
-      raise "To many values for row, argument #{i}" if args.length > fields.length
+      raise KType::Error, "To many values for row, argument #{args.length}" if args.length > fields.length
 
       # Apply column names with defaults
+
       row = fields.each_with_object({}) do |f, hash|
         hash[f['name']] = f['default']
       end
@@ -60,6 +80,10 @@ module KDoc
     end
     # rubocop:enable Naming/AccessorMethodName
 
+    def internal_data
+      @data[@name]
+    end
+
     def find_row(key, value)
       @data[@name]['rows'].find { |r| r[key] == value }
     end
@@ -91,16 +115,45 @@ module KDoc
     end
     alias f field
 
+    def debug
+      log.o(KUtil.data.to_open_struct(internal_data))
+    end
+
     private
 
+    # This method can move into decorator helpers
+    # Run decorators a maximum of once for each behaviour
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def run_decorators(behaviour)
+      return if behaviour == :update_fields && @has_executed_field_decorators
+      return if behaviour == :update_rows && @has_executed_row_decorators
+
+      @has_executed_field_decorators = true if behaviour == :update_fields
+
+      @has_executed_rows_decorators = true if behaviour == :update_rows
+
+      decorators.each { |decorator| decorator.decorate(self, behaviour) }
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    # rubocop:disable Metrics/AbcSize
     def initialize_attributes(data, name = nil, **options)
       @data = data
       @name = (name || FakeOpinion.new.default_table_key.to_s).to_s
 
       @parent = options[:parent] if !options.nil? && options.key?(:parent)
 
+      # This code needs to work differently, it needs to support the 3 different types
+      # Move the query into helpers
+      decorator_list = options[:decorators].nil? ? [] : options[:decorators]
+
+      @decorators = decorator_list
+                    .map(&:new)
+                    .select { |decorator| decorator.compatible?(self) }
+
       @data[@name] = { 'fields' => [], 'rows' => [] }
     end
+    # rubocop:enable Metrics/AbcSize
 
     def respond_to_missing?(name, *_args, &_block)
       (!@parent.nil? && @parent.respond_to?(name, true)) || super

data/lib/k_doc/util.rb

@@ -3,12 +3,18 @@
 module KDoc
   # Utility helper methods for KDoc
   class Util
-    def build_unique_key(key, type = nil, namespace = nil)
+    # Build a unique key so that resources of the same key do not conflict with
+    # one another across projects, namespaces or types
+    #
+    # @param [String] param_name Param description
+    def build_unique_key(key, type = nil, namespace = nil, project_key = nil)
       raise KDoc::Error, 'key is required when generating unique key' if key.nil? || key.empty?
 
       type ||= KDoc.opinion.default_document_type
 
-      namespace.nil? || namespace.empty? ? "#{key}_#{type}" : "#{namespace}_#{key}_#{type}"
+      keys = [project_key, namespace, key, type].reject { |k| k.nil? || k == '' }
+
+      keys.join('_')
     end
   end
 end

data/lib/k_doc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module KDoc
-  VERSION = '0.0.5'
+  VERSION = '0.0.11'
 end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: k_doc
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.11
 platform: ruby
 authors:
 - David Cruwys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-04-01 00:00:00.000000000 Z
+date: 2021-04-21 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: k_decor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.0
 - !ruby/object:Gem::Dependency
   name: k_log
   requirement: !ruby/object:Gem::Requirement
@@ -24,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.0.0
+- !ruby/object:Gem::Dependency
+  name: k_type
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.0
 - !ruby/object:Gem::Dependency
   name: k_util
   requirement: !ruby/object:Gem::Requirement
@@ -57,6 +99,7 @@ files:
 - README.md
 - Rakefile
 - STORIES.md
+- ToDo.md
 - USAGE.md
 - bin/console
 - bin/k
@@ -67,8 +110,10 @@ files:
 - hooks/update-version
 - k_doc.gemspec
 - lib/k_doc.rb
+- lib/k_doc/container.rb
 - lib/k_doc/data.rb
-- lib/k_doc/document.rb
+- lib/k_doc/decorators/settings_decorator.rb
+- lib/k_doc/decorators/table_decorator.rb
 - lib/k_doc/fake_opinion.rb
 - lib/k_doc/settings.rb
 - lib/k_doc/table.rb

data/lib/k_doc/document.rb

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-
-module KDoc
-  # General purpose document DSL
-  #
-  # Made up of 0 or more setting groups and table groups
-  class Document
-    attr_reader :key
-    attr_reader :type
-    attr_reader :namespace
-    attr_reader :options
-    attr_reader :error
-
-    # Create document
-    #
-    # @param [String|Symbol] name Name of the document
-    # @param args[0] Type of the document, defaults to KDoc:: FakeOpinion.new.default_document_type if not set
-    # @param default: Default value (using named params), as above
-    def initialize(key = SecureRandom.alphanumeric(8), **options, &block)
-      initialize_attributes(key, **options)
-
-      @block = block if block_given?
-    end
-
-    def execute_block(run_actions: nil)
-      return if @block.nil?
-
-      # The DSL actions method will only run on run_actions: true
-      @run_actions = run_actions
-
-      instance_eval(&@block)
-
-      on_action if run_actions && respond_to?(:on_action)
-    # rescue KDoc::Error => e
-    #   puts('KDoc::Error in document')
-    #   puts "key #{unique_key}"
-    #   # puts "file #{KUtil.data.console_file_hyperlink(resource.file, resource.file)}"
-    #   puts(e.message)
-    #   @error = e
-    #   raise
-    rescue StandardError => e
-      L.error('Standard error in document')
-      puts "key #{unique_key}"
-      # puts "file #{KUtil.data.console_file_hyperlink(resource.file, resource.file)}"
-      L.error(e.message)
-      @error = e
-      # L.exception exception2
-      raise
-    ensure
-      @run_actions = nil
-    end
-
-    def unique_key
-      @unique_key ||= KDoc.util.build_unique_key(key, type, namespace)
-    end
-
-    def settings(key = nil, **options, &block)
-      options ||= {}
-
-      opts = {}.merge(@options) # Document Options
-               .merge(options)  # Settings Options
-               .merge(parent: self)
-
-      settings_instance(@data, key, **opts, &block)
-      # settings.run_decorators(opts)
-    end
-
-    def table(key = :table, **options, &block)
-      # NEED to add support for run_decorators I think
-      options.merge(parent: self)
-      table_instance(@data, key, **options, &block)
-    end
-    alias rows table
-
-    # Sweet add-on would be builders
-    # def builder(key, &block)
-    #   # example
-    #   KDoc::Builder::Shotstack.new(@data, key, &block)
-    # end
-
-    # def set_data(data)
-    #   @data = data
-    # end
-
-    def data
-      @data.clone
-    end
-
-    def data_struct
-      KUtil.data.to_open_struct(data)
-    end
-    # alias d data_struct
-
-    def raw_data_struct
-      KUtil.data.to_open_struct(raw_data)
-    end
-
-    def get_node_type(node_name)
-      node_name = KUtil.data.clean_symbol(node_name)
-      node_data = @data[node_name]
-
-      raise KDoc::Error, "Node not found: #{node_name}" if node_data.nil?
-
-      if node_data.keys.length == 2 && (node_data.key?('fields') && node_data.key?('rows'))
-        :table
-      else
-        :settings
-      end
-    end
-
-    # Removes any meta data eg. "fields" from a table and just returns the raw data
-    def raw_data
-      # REFACT, what if this is CSV, meaning it is just an array?
-      #         add specs
-      result = data
-
-      result.each_key do |key|
-        # ANTI: get_node_type uses @data while we are using @data.clone here
-        data[key] = if get_node_type(key) == :table
-                      result[key].delete('fields')
-                    else
-                      result[key]
-                    end
-      end
-
-      data
-    end
-
-    # Move this out to the logger function when it has been refactor
-    def debug(include_header: false)
-      debug_header if include_header
-
-      # tp dsls.values, :k_key, :k_type, :state, :save_at, :last_at, :data, :last_data, :source, { :file => { :width => 150 } }
-      # puts JSON.pretty_generate(data)
-      L.o(raw_data_struct)
-    end
-
-    def debug_header
-      L.heading self.class.name
-      L.kv 'key', key
-      L.kv 'type', type
-      L.kv 'namespace', namespace
-      L.kv 'error', error
-
-      debug_header_keys
-
-      L.line
-    end
-
-    def debug_header_keys
-      options&.keys&.reject { |k| k == :namespace }&.each do |key|
-        L.kv key, options[key]
-      end
-    end
-
-    private
-
-    def initialize_attributes(key = nil, **options)
-      @key = key
-
-      @options    = options || {}
-      @type       = slice_option(:type) || KDoc.opinion.default_document_type
-      @namespace  = slice_option(:namespace) || ''
-      @parent     = slice_option(:parent)
-
-      # Most documents live within a hash, some tabular documents such as CSV will use an []
-      @data       = slice_option(:default_data) || {}
-
-      @error = nil
-    end
-
-    def settings_instance(data, key, **options, &block)
-      KDoc.opinion.settings_class.new(data, key, **options, &block)
-    end
-
-    def table_instance(data, key, **options, &block)
-      KDoc.opinion.table_class.new(data, key, **options, &block)
-    end
-
-    def slice_option(key)
-      return nil unless @options.key?(key)
-
-      result = @options[key]
-      @options.delete(key)
-      result
-    end
-  end
-end