cmdlet 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d66542098bfbb9641d3c40c9de148303dc603be24fac2c1b7bbd1c20ef76a362
-  data.tar.gz: bd50bf086ba1c020f30986152fe0a8fc3084391d03f86416862cf8c8713d53ed
+  metadata.gz: bfdaac05f95db1014dc0a28dca06d7af071a40b46ccf79398ae7e15cef3d73ab
+  data.tar.gz: f90974598208b711a674c2a9dacd850dcea8be72f79d8cf2bddd11425c98a706
 SHA512:
-  metadata.gz: 7a8d4b61be26278b044e61d702741c1ce9317e32ff9f731e3bf4e1beacd1e4c474607071d552ddc854bbba65817d110c38b543f4858b6a51669a7ea4578754f6
-  data.tar.gz: 59f3bcd0f17b54a3e4044c14656ee6ebde73e7f434fcd2b82e14ed79206c26bb8651ec6b7921bb16adc1ad88c00a0d994e8f2c5bb93da65f4289e2a17e0a4613
+  metadata.gz: 04b7ea36c7db18bb2becc84ea1fda21856a906d39d3b0a3c390a159fce77e40dcdb752da1c810ce14cb7b5205bee8ebfe884ac467d724081e16f6adc468078d1
+  data.tar.gz: bc84349086aeb4be3d8c5a9f3e595e84f39596af58592cbc4be16ed2f6856d4c342a1c9ab6b8ab3f4d9f52683665aed7f2fc9cf2a1f7ed7d386dd128898a8a42

data/.builders/_.rb

@@ -1 +1 @@
-# require_relative './path/here'
+require_relative './documents/_'

data/.builders/documents/_.rb

@@ -0,0 +1,4 @@
+require_relative './categories'
+require_relative './functions'
+require_relative './use_cases'
+require_relative './commands'

data/.builders/documents/categories.rb

@@ -0,0 +1,24 @@
+def categories
+  return @categories unless @categories.nil?
+
+  
+  result = KDoc.model :document do
+    table :rows do
+      fields :name, :description
+
+      row :case               , "Tokenize and apply case and/or separator"
+      row :comparison         , "Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc."
+      row :inflection         , "Inflection handling routines, eg. pluralize, singular, ordinalize"
+      row :string             , "String handling helpers"
+
+      row :a_array            , "Array handling routines, eg. join, join_prefix, join_post"
+      row :a_transform        , "Tokenize and apply case and/or separator"
+      row :a_comparison       , "Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc."
+      row :a_inflection       , "Inflection handling routines, eg. pluralize, singular, ordinalize"
+    end
+  end
+  
+  @categories = result.raw_data_struct.rows
+end
+@categories = nil
+

data/.builders/documents/commands.rb

@@ -0,0 +1,31 @@
+def commands
+  functions.map do |function|
+    category = categories.find { |c| c.name == function.category }
+
+    
+    log.error("Category '#{function.category}' not found") unless category
+  
+    OpenStruct.new(
+      category: function.category,
+      name: function.name,
+      category_description: category.description,
+      function_description: function.description,
+      ruby: function.ruby,
+      usecases: use_cases
+        .select { |uc| uc.category == function.category && uc.function == function.name }
+        .map { |uc| 
+          OpenStruct.new({
+            category:         uc.category,
+            function:         uc.function,
+            inputs:           uc.inputs,
+            nice_inputs:      nice_inputs(uc.inputs),
+            expected_output:  uc.expected_output 
+          })
+        }
+    )
+  end
+end
+
+def nice_inputs(values)
+  values.map { |value| value.is_a?(String) ? "'#{value}'" : value }.join(', ')
+end

data/.builders/documents/functions.rb

@@ -0,0 +1,226 @@
+def functions
+  return @functions unless @functions.nil?
+  
+  result = KDoc.model :document do
+    table :rows do
+      fields :category, :name, :alias, :description, :ruby # , f(name: :params, default: [:value])
+
+      # context 'when array of string' do
+      #   let(:value) { %w[the quick fox] }
+
+      #   it { is_expected.to eq('the,quick,fox') }
+      # end
+
+      # context 'when array of numbers' do
+      #   let(:value) { [1, 2, 3] }
+
+      #   it { is_expected.to eq('1,2,3') }
+      # end
+
+      # context 'when array of symbol' do
+      #   let(:value) { %i[the quick fox] }
+
+      #   it { is_expected.to eq('the,quick,fox') }
+      # end
+
+      row :a_array                , :join            , []    , "join an array of values with separator as a string", <<-'RUBY'
+        return '' if value.nil? || !value.is_a?(Array)
+        values = value.reject(&:blank?)
+        return '' if value.length.zero?
+
+        separator = ','
+        value.join(separator)
+      RUBY
+
+      row :a_array                , :join_pre        , []    , "join an array of values with separator as a string and using the separator at the beginning of string", <<-'RUBY'
+        return '' if value.nil? || !value.is_a?(Array)
+        values = value.reject(&:blank?)
+        return '' if value.length.zero?
+
+        separator = ','
+        "#{separator}#{value.join(separator)}"
+      RUBY
+
+      row :a_array                , :join_post       , []    , "join an array of values with separator as a string and using the separator at the end of string", <<-'RUBY'
+        return '' if value.nil? || !value.is_a?(Array)
+        values = value.reject(&:blank?)
+        return '' if value.length.zero?
+
+        separator = ','
+        "#{value.join(separator)}#{separator}"
+      RUBY
+
+      row :a_transform            , :backslash            , [:back_slash]                    , "convert to back slash notation", <<-'RUBY'
+        tokenizer.parse(value, preserve_case: true, separator: '\\')
+      RUBY
+
+      row :a_transform            , :camel                , [:upper_camel, :pascal]          , "convert to camel notation", <<-'RUBY'
+        tokenizer.parse(value).underscore.camelize
+      RUBY
+
+      row :a_transform            , :constant             , [:constantize]                   , "", <<-'RUBY'
+        tokenizer.parse(value, separator: '_').upcase      
+      RUBY
+
+      row :a_transform            , :dash                 , [:dasherize]                     , "convert to dash notation", <<-'RUBY'
+        tokenizer.parse(value)
+      RUBY
+
+      row :a_transform            , :dot                  , [:dotirize]                      , "", <<-'RUBY'
+        tokenizer.parse(value, separator: '.')
+      RUBY
+
+      row :a_transform            , :double_colon         , []                               , "", <<-'RUBY'
+        tokenizer.parse(value, preserve_case: true, separator: '::')
+      RUBY
+
+      row :a_transform            , :lower                , [:lowercase, :downcase]          , "", <<-'RUBY'
+        return '' if value.nil?
+
+        value.downcase
+      RUBY
+
+      # row :a_transform            , :format_as            , []                               , "", <<-'RUBY'
+      
+      # RUBY
+
+      row :a_transform            , :proper            , []                               , "Proper case capitalizes the first letter of ALL words in a string", <<-'RUBY'
+      tokenizer.parse(value,
+              separator: ' ',
+              preserve_case: true,
+              compress_prefix_numerals: false,
+              compress_suffix_numerals: false)
+        .titleize
+      RUBY
+
+      row :a_transform            , :sentence             , [:human, :humanize]              , "Upper case for first letter only.  Numbers will maintain their spacing", <<-'RUBY'
+        tokenizer.parse(value,
+                        separator: ' ',
+                        preserve_case: true,
+                        compress_prefix_numerals: false,
+                        compress_suffix_numerals: false)
+                  .humanize
+      RUBY
+
+      row :a_transform            , :lamel                , [:lower_camel]                   , "", <<-'RUBY'
+        tokenizer.parse(value, separator: '_').camelize(:lower)
+      RUBY
+
+      row :a_transform            , :slash                , [:forwardslash, :forward_slash]  , "", <<-'RUBY'
+        tokenizer.parse(value, preserve_case: true, separator: '/')
+      RUBY
+
+      row :a_transform            , :snake                , [:snake]                         , "", <<-'RUBY'
+        tokenizer.parse(value, separator: '_', forced_separator: true)
+      RUBY
+
+      row :a_transform            , :title                , [:titleize]                      , "", <<-'RUBY'
+        tokenizer.parse(value,
+                        separator: ' ',
+                        preserve_case: true,
+                        compress_prefix_numerals: false,
+                        compress_suffix_numerals: false)
+                 .titleize
+      RUBY
+
+      row :a_transform            , :upper                , [:upper_case, :upcase]           , "", <<-'RUBY'
+        return '' if value.nil?
+
+        value.upcase
+      RUBY
+
+  
+      row :a_comparison         , :and                  , [:all] , "", <<-'RUBY'
+        values.all? { |value| value }
+      RUBY
+
+      # DEFAULT does not make sense in comparison
+      row :a_comparison         , :default              , [:fallback] , "", <<-'RUBY'
+        default_value = values[-1]
+
+        find_value = values[0..-2].find { |value| !value.nil? }
+
+        find_value || default_value
+      RUBY
+
+      row :a_comparison         , :eq                   , [:equal] , "", <<-'RUBY'
+        lhs = lhs.to_s if lhs.is_a?(Symbol)
+        rhs = rhs.to_s if rhs.is_a?(Symbol)
+
+        lhs == rhs
+      RUBY
+
+      row :a_comparison         , :gt                   , [] , "", <<-'RUBY'
+        lhs > rhs
+      RUBY
+
+      row :a_comparison         , :gte                  , [] , "", <<-'RUBY'
+        lhs >= rhs
+      RUBY
+
+      row :a_comparison         , :lt                   , [:less_than] , "# Lt: (less than) Block helper that renders a block if `a` is **less than** `b`. If an inverse block is specified it will be rendered when falsy.", <<-'RUBY'
+        lhs < rhs
+      RUBY
+
+      row :a_comparison         , :lte                  , [:less_than_or_equal_to] , "# Lte: (less than or equal to) Block helper that renders a block if `a` is **less than or equal to** `b`. If an inverse block is specified it will be rendered when falsy.", <<-'RUBY'
+        lhs <= rhs
+      RUBY
+
+      row :a_comparison         , :ne                   , [:not_equal] , "# Ne: (not equal) Block helper that renders a block if `a` is **not equal to** `b`. If an inverse block is specified it will be rendered when falsy.", <<-'RUBY'
+        lhs = lhs.to_s if lhs.is_a?(Symbol)
+        rhs = rhs.to_s if rhs.is_a?(Symbol)
+
+        lhs != rhs
+      RUBY
+
+      row :a_comparison         , :or                   , [:any] , "", <<-'RUBY'
+        values.any? { |value| value }
+      RUBY
+
+
+
+      row :a_inflection         , :ordinal              , [] , "The suffix that should be added to a number to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th", <<-RUBY
+        return '' if value.nil?
+
+        value = value.to_i if value.is_a? String
+
+        value.ordinal
+      RUBY
+
+      row :a_inflection         , :ordinalize           , [] , "Turns a number into an ordinal string used to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.", <<-RUBY
+        return '' if value.nil?
+
+        value = value.to_i if value.is_a? String
+
+        value.ordinalize
+      RUBY
+
+      row :a_inflection         , :pluralize            , [] , "Returns the plural form of the word in the string", <<-RUBY
+        return '' if value.nil?
+
+        value = value.to_s if value.is_a?(Symbol)
+
+        value.pluralize
+      RUBY
+
+      row :a_inflection         , :pluralize_by_number  , [] , "Uses both a word and number to decide if the plural or singular form should be used.", <<-'RUBY'
+        return '' if value.nil?
+
+        count = count.to_i if count.is_a? String
+        format = :word if format.nil?
+
+        case format.to_sym
+        when :number_word, :number_and_word
+          "#{count} #{value.pluralize(count)}"
+        else # aka :word
+          value.pluralize(count)
+        end
+      RUBY
+      
+      # row :a_inflection         , :singularize          , [] , ""
+    end
+  end
+  
+  @functions = result.raw_data_struct.rows
+end
+@functions = nil

data/.builders/documents/use_cases.rb

@@ -0,0 +1,136 @@
+def use_cases
+  return @use_cases unless @use_cases.nil?
+  
+  result = KDoc.model :document do
+
+    # table :inputs do
+    #   fields :name, :value
+
+    #   row :title              , "Account Category"
+    #   row :bsb_account        , "ABC 123"
+    #   row :text1              , "the Quick brown Fox 99"
+    #   row :sentence1          , "The quick  brown fox, jumped  over the lazy dog"
+    #   row :sentence2          , "The quick brown fox"
+    #   row :sentence3          , "jumped over the lazy dog"
+    #   row :num1               , 1
+    #   row :num2               , 2
+    #   row :num3               , 3
+
+    # end
+
+    sentence1 = "The quick  brown fox, jumped  over the lazy dog"
+    sentence2 = "coyote and the acme company"
+    text1     = "the Quick brown Fox 99"
+
+    table :rows do
+      # fields :category, :function, :input, :commands, :expected_value
+      fields :category  , :function, :inputs, :expected_output
+
+      row :a_inflection , :ordinal        , [1], 'st'
+      row :a_inflection , :ordinal        , [2], 'nd'
+      row :a_inflection , :ordinal        , [3], 'rd'
+      row :a_inflection , :ordinal        , [4], 'th'
+      row :a_inflection , :ordinal        , ['101'], 'st'
+      row :a_inflection , :ordinal        , ['105'], 'th'
+
+      row :a_inflection , :ordinalize     , [1], '1st'
+      row :a_inflection , :ordinalize     , [2], '2nd'
+      row :a_inflection , :ordinalize     , [3], '3rd'
+      row :a_inflection , :ordinalize     , [4], '4th'
+      row :a_inflection , :ordinalize     , ['101'], '101st'
+      row :a_inflection , :ordinalize     , ['105'], '105th'
+
+      row :a_inflection , :pluralize      , ['name'], 'names'
+      row :a_inflection , :pluralize      , ['octopus'], 'octopi'
+
+      row :a_transform  , :backslash      , [text1]     , 'the\quick\brown\fox99'
+      row :a_transform  , :camel          , [text1]     , 'TheQuickBrownFox99'
+      row :a_transform  , :constant       , [text1]     , 'THE_QUICK_BROWN_FOX99'
+      row :a_transform  , :dash           , [text1]     , 'the-quick-brown-fox99'
+      row :a_transform  , :dot            , [text1]     , 'the.quick.brown.fox99'
+      row :a_transform  , :double_colon   , [text1]     , 'The::Quick::Brown::Fox99'
+      row :a_transform  , :lower          , [text1]     , 'the quick brown fox 99'
+      row :a_transform  , :lamel          , [text1]     , 'theQuickBrownFox99'
+      row :a_transform  , :proper         , [text1]     , 'The Quick Brown Fox 99'
+      row :a_transform  , :proper         , [sentence1] , 'The Quick Brown Fox Jumped Over The Lazy Dog'
+      row :a_transform  , :sentence       , [text1]     , 'The quick brown fox 99'
+      row :a_transform  , :sentence       , [sentence1] , 'The quick brown fox jumped over the lazy dog'
+      # row :a_transform  , :sentence       , [sentence2] , 'Coyote and the ACME company'
+
+      row :a_transform  , :slash          , [text1]     , 'the/Quick/brown/Fox99'
+      row :a_transform  , :snake          , [text1]     , 'the_quick_brown_fox99'
+      row :a_transform  , :title          , [text1]     , 'The Quick Brown Fox 99'
+      row :a_transform  , :title          , [sentence1] , 'The Quick Brown Fox Jumped over the Lazy Dog'
+      row :a_transform  , :upper          , [text1]     , 'THE QUICK BROWN FOX 99'
+      
+
+      row :a_comparison , :and            , [nil, nil]        , false
+      row :a_comparison , :and            , ['data', nil]     , false
+      row :a_comparison , :and            , [nil, 'data']     , false
+      row :a_comparison , :and            , ['data', 'data']  , true
+      row :a_comparison , :and            , ['aaa', 'bbb']    , true
+
+      # DEFAULT does not make sense in comparison
+      row :a_comparison , :default        , [nil, 'happy'] , "happy"
+      row :a_comparison , :default        , ['sad', 'happy'] , "sad"
+      row :a_comparison , :default        , [nil, nil, nil, nil, 'david'] , "david"
+      row :a_comparison , :default        , ['', 'happy'] , "happy"
+
+      # type: :strict, :equiv, :cast, :insensitive
+      row :a_comparison , :eq             , [111, '111'  ], false
+      row :a_comparison , :eq             , [111, 111.0  ], false
+      row :a_comparison , :eq             , ['aaa', 'aaa'], true
+      row :a_comparison , :eq             , ['aaa', 'bbb'], false
+      row :a_comparison , :eq             , [:aaa,  :aaa] , true
+      row :a_comparison , :eq             , ['aaa', :aaa] , false
+      row :a_comparison , :eq             , ['aaa', 'bbb'], false
+      row :a_comparison , :eq             , ['aaa', 'AAA'], false
+
+      row :a_comparison , :gt             , [2, 1] , true
+      row :a_comparison , :gt             , [2, 2] , false
+      
+      row :a_comparison , :gte            , [1, 2] , false
+      row :a_comparison , :gte            , [1, 1] , true
+      row :a_comparison , :gte            , [2, 1] , true
+      
+      row :a_comparison , :lt             , [1, 2] , true
+      row :a_comparison , :lt             , [2, 1] , false
+
+      row :a_comparison , :lte            , [1, 2] , true
+      row :a_comparison , :lte            , [2, 2] , true
+      row :a_comparison , :lte            , [2, 1] , false
+
+      row :a_comparison , :ne             , [1, 2] , true
+      row :a_comparison , :ne             , [1, 1] , false
+      
+      row :a_comparison , :or             , [nil, nil]        , false
+      row :a_comparison , :or             , ['data', nil]     , true
+      row :a_comparison , :or             , [nil, 'data']     , true
+      row :a_comparison , :or             , ['data', 'data']  , true
+      row :a_comparison , :or             , ['aaa', 'bbb']    , true
+      # row :text1          , %i[backslash]     , 'the\quick\brown\fox99'
+      # row :text1          , %i[camel]         , 'TheQuickBrownFox99'
+
+
+      # row :sentence3      , %i[plural]        , "jumped over the lazy dogs"
+      # row :title          , %i[plural]        , "Account Categories"
+      # row :sentence1      , %i[dash]          , "The-quick-brown-fox-jumped-over-the-lazy-dog"
+      # row :sentence1      , %i[natural]       , "The quick brown fox, jumped over the lazy dog"
+      # row :sentence1      , %i[lower dash]    , "the-quick-brown-fox-jumped-over-the-lazy-dog"
+      # row :bsb_account    , %i[lower snake]   , "abc_123"
+      # row :bsb_account    , %i[slash]         , "ABC/123"
+    end
+
+  end
+  
+  @use_cases = result.raw_data_struct.rows
+end
+@use_cases = nil
+
+  # def self.camel_case(string, tokenizer = PreservePrefixedUnderscoreTokenizer.new)
+  #   # DAVE INPUT 9 Oct 21 from lucky_case play
+  #   # dependency injection: to use enhanced tokenizer
+  #   a = split_case_string string
+  #   converted = ([a[0]] + a[1..-1].map { |e| capital e }).join('')
+  #   tokenizer.parse(converted)
+  # end

data/.builders/documents/x_functions.rb

@@ -0,0 +1,66 @@
+
+def category_blueprint
+
+  fn_builder
+    .init
+    .category(:array      , active: 0 , title: 'Array'       , description: 'Functions for working with Array')
+    .category(:cases      , active: 0 , title: 'Cases'       , description: 'Functions for working with Cases')
+    .category(:code       , active: 0 , title: 'Code'        , description: 'Functions for working with Code')
+    .category(:collection , active: 0 , title: 'Collection'  , description: 'Functions for working with Collection')
+    .category(:comparison , active: 0 , title: 'Comparison'  , description: 'Functions for working with Comparison')
+    .category(:date       , active: 0 , title: 'Date'        , description: 'Functions for working with Date')
+    .category(:file       , active: 0 , title: 'File'        , description: 'Functions for working with File')
+    .category(:html       , active: 0 , title: 'Html'        , description: 'Functions for working with Html')
+    .category(:i18n       , active: 0 , title: 'I18n'        , description: 'Functions for working with Internationalization')
+    .category(:inflection , active: 1 , title: 'Inflection'  , description: 'Functions for working with Inflection')
+    .category(:logging    , active: 0 , title: 'Logging'     , description: 'Functions for working with Logging')
+    .category(:markdown   , active: 0 , title: 'Markdown'    , description: 'Functions for working with Markdown')
+    .category(:match      , active: 0 , title: 'Match'       , description: 'Functions for working with Match')
+    .category(:math       , active: 0 , title: 'Math'        , description: 'Functions for working with Math')
+    .category(:misc       , active: 0 , title: 'Misc'        , description: 'Functions for working with Misc')
+    .category(:number     , active: 0 , title: 'Number'      , description: 'Functions for working with Number')
+    .category(:object     , active: 0 , title: 'Object'      , description: 'Functions for working with Object')
+    .category(:path       , active: 0 , title: 'Path'        , description: 'Functions for working with Path')
+    .category(:regex      , active: 0 , title: 'Regex'       , description: 'Functions for working with Regex')
+    .category(:string     , active: 0 , title: 'String'      , description: 'Functions for working with String')
+    .category(:url        , active: 0 , title: 'Url'         , description: 'Functions for working with Url')
+
+end
+
+def function_blueprint
+
+  fn_builder
+    .init
+    .for_category(:array)
+    .for_category(:cases)
+    .for_category(:code)
+    .for_category(:collection)
+    .for_category(:comparison)
+    .for_category(:date)
+    .for_category(:file)
+    .for_category(:html)
+    .for_category(:i18n)
+    .for_category(:inflection)
+      .function(:ordinal)
+      .function(:ordinalize)
+      .function(:pluralize_by_number)
+      .function(:pluralize)
+      .function(:singularize)
+    .for_category(:logging)
+    .for_category(:markdown)
+    .for_category(:match)
+    .for_category(:math)
+    .for_category(:misc)
+    .for_category(:number)
+    .for_category(:object)
+    .for_category(:path)
+    .for_category(:regex)
+    .for_category(:string)
+    .for_category(:url)
+
+end
+
+# {{arrayify}}
+# Cast the given value to an array.
+# {{before}}
+# Return all of the items in the collection before the specified count. Opposite of after.

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.0.3](https://github.com/klueless-io/cmdlet/compare/v0.0.2...v0.0.3) (2022-07-08)
+
+
+### Bug Fixes
+
+* base files for new GEM - [#2](https://github.com/klueless-io/cmdlet/issues/2) ([9d52c68](https://github.com/klueless-io/cmdlet/commit/9d52c68acfe98954c456859d40edf7db6e74e044))
+
 ## [0.0.2](https://github.com/klueless-io/cmdlet/compare/v0.0.1...v0.0.2) (2022-07-08)
 
 

data/lib/cmdlet/configuration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Register this configuration access extension for Cmdlet configuration
+  module CmdletConfigurationExtension
+    def cmdlet
+      return @cmdlet if defined? @cmdlet
+
+      @cmdlet = CmdletConfiguration.new
+    end
+  end
+
+  # Structure for storing Cmdlet configuration
+  class CmdletConfiguration
+    include KLog::Logging
+
+    attr_accessor :tokenizer
+    attr_accessor :padl_count
+    attr_accessor :padl_char
+    attr_accessor :padr_count
+    attr_accessor :padr_char
+
+    def initialize
+      # @tokenizer = Funcky::StringTokenizer.new
+      @padr_count = 30
+      @padr_char = ' '
+      @padl_count = 30
+      @padl_char = ' '
+    end
+  end
+end
+
+KConfig::Configuration.register(:cmdlet, Cmdlet::CmdletConfigurationExtension)

data/lib/cmdlet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cmdlet
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

data/lib/cmdlet.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
+# require 'k_log'
+require 'k_config'
 require_relative 'cmdlet/version'
+require_relative 'cmdlet/configuration'
 
 module Cmdlet
   # raise Cmdlet::Error, 'Sample message'

data/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "cmdlet",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "cmdlet",
-      "version": "0.0.3",
+      "version": "0.0.4",
       "devDependencies": {
         "@klueless-js/semantic-release-rubygem": "github:klueless-js/semantic-release-rubygem",
         "@semantic-release/changelog": "^6.0.1",

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cmdlet",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Cmdlet provides a set of functions (wrapped in the command pattern) that perform simple actions",
   "scripts": {
     "release": "semantic-release"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cmdlet
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - David Cruwys
@@ -11,19 +11,19 @@ cert_chain: []
 date: 2022-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: k_log
+  name: k_config
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.0
+        version: 0.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.0
+        version: 0.0.3
 description: "    Cmdlet provides a set of functions (wrapped in the command pattern)
   that perform simple actions\n"
 email:
@@ -34,6 +34,12 @@ extra_rdoc_files: []
 files:
 - ".builders/_.rb"
 - ".builders/boot.rb"
+- ".builders/documents/_.rb"
+- ".builders/documents/categories.rb"
+- ".builders/documents/commands.rb"
+- ".builders/documents/functions.rb"
+- ".builders/documents/use_cases.rb"
+- ".builders/documents/x_functions.rb"
 - ".builders/generators/01-bootstrap.rb"
 - ".releaserc.json"
 - ".rspec"
@@ -48,6 +54,7 @@ files:
 - bin/console
 - bin/setup
 - lib/cmdlet.rb
+- lib/cmdlet/configuration.rb
 - lib/cmdlet/version.rb
 - package-lock.json
 - package.json