cmdlet 0.0.4 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfdaac05f95db1014dc0a28dca06d7af071a40b46ccf79398ae7e15cef3d73ab
-  data.tar.gz: f90974598208b711a674c2a9dacd850dcea8be72f79d8cf2bddd11425c98a706
+  metadata.gz: 49865609277b82bf27cc7275b38f0830109e2228b8ab3629ca1774d07b85f834
+  data.tar.gz: 7d6c2c92910fc466f8f0d3e04ebb4356dfb070c17e553a3e573c60e946648032
 SHA512:
-  metadata.gz: 04b7ea36c7db18bb2becc84ea1fda21856a906d39d3b0a3c390a159fce77e40dcdb752da1c810ce14cb7b5205bee8ebfe884ac467d724081e16f6adc468078d1
-  data.tar.gz: bc84349086aeb4be3d8c5a9f3e595e84f39596af58592cbc4be16ed2f6856d4c342a1c9ab6b8ab3f4d9f52683665aed7f2fc9cf2a1f7ed7d386dd128898a8a42
+  metadata.gz: d7bd4e1e6364146d104a96bd66425df76f3bd164b350f1b3328f046cc8c8e2b6f2d65eec9dacd18c7ce510e064846f10b0ba2a49315089f6ff0235e494b34387
+  data.tar.gz: e0ddc16a51d5c16957ac2241098de2f1a7a0de777f59621d8398da8e61172ae07c9ea796971e48ce024a646eee0c6b29cd1fe93fde4c6840c0d41b497c63da14

data/.builders/.templates/FUNCTIONS.MD

@@ -0,0 +1,19 @@
+# Funcky Functions
+
+> Funcky provides a set of functions (wrapped in the command pattern) that perform simple actions
+
+## List of categories
+
+| Name | Description |
+|-|-|
+{{#each categories}}
+| {{titleize name}} | {{description}} |
+{{/each}}
+
+## List of functions
+
+| Category | Name | Alias | Description |
+|-|-|-|-|
+{{#each functions}}
+| {{titleize category}} | `{{name}}` | {{#each alias}}{{surround . '`' '` '}}{{/each}} | {{description}} |
+{{/each}}

data/.builders/.templates/all_commands.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+{{#each commands}}
+require 'cmdlet/{{category}}/{{name}}'
+{{/each}}

data/.builders/.templates/command.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# reference: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
+
+module Cmdlet
+  # {{cmdlet.category_description}}
+  module {{camel cmdlet.category}}
+    # {{camel cmdlet.name}}: {{cmdlet.command_description}}
+    class {{camel cmdlet.name}} < Funcky::BaseFunction
+      {{#each cmdlet.usecases}}
+      # @example
+      #
+      #   puts {{camel ./function}}.new.parse({{{nice_inputs}}})
+      #
+      #   {{expected_output}}
+      #
+      {{/each}}
+      #
+      # @param [String|Int] value - numeric value
+      # @return [String] ordinal suffix that would be required for a number
+      def parse(value)
+{{{cmdlet.ruby}}}
+      end
+    end
+  end
+end

data/.builders/.templates/command_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# {{camel command.name}}: {{command.function_description}}
+RSpec.describe Funcky::{{camel command.category}}::{{camel command.name}} do
+  let(:instance) { described_class.new }
+  
+  describe 'initialize' do
+    subject { instance }
+  
+    it { is_expected.not_to be_nil }
+  end
+
+  describe '#parse' do
+    subject { instance.parse(value) }
+
+    let(:value) { nil }
+
+    context 'safely handle nil' do
+      it { is_expected.to eq('') }
+    end
+  end
+end

data/.builders/_.rb

@@ -1 +1,5 @@
-require_relative './documents/_'
+# require_relative './documents/_'
+require_relative './director/category_director'
+require_relative './director/cmdlet_builder'
+require_relative './director/cmdlet_director'
+require_relative './director/cmdlet_child'

data/.builders/boot.rb

@@ -49,10 +49,10 @@ KConfig.configure(CONFIG_KEY) do |config|
   config.template_folders.add(:template           , File.expand_path('.templates', Dir.pwd))
 
   config.target_folders.add(:app                  , base_folder)
-  config.target_folders.add(:lib                  , :app, 'lib/funcky')
-  config.target_folders.add(:spec                 , :app, 'spec/funcky')
+  config.target_folders.add(:lib                  , :app, 'lib/cmdlet')
+  config.target_folders.add(:spec                 , :app, 'spec/cmdlet')
   config.target_folders.add(:builder              , builder_folder)
-
+  config.target_folders.add(:builder_data         , :builder, 'data')
 end
 
 KConfig.configuration(CONFIG_KEY).debug
@@ -62,6 +62,7 @@ resource_manager = area.resource_manager
 resource_manager
   .fileset
   .glob('*.rb', exclude: ['boot.rb'])
+  .glob('documents/**/*.rb')
   .glob('generators/**/*.rb')
 resource_manager.add_resources
 

data/.builders/data/categories.json

@@ -0,0 +1,36 @@
+{
+  "categories": [
+    {
+      "name": "case",
+      "description": "Tokenize and apply case and/or separator"
+    },
+    {
+      "name": "comparison",
+      "description": "Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc."
+    },
+    {
+      "name": "inflection",
+      "description": "Inflection handling routines, eg. pluralize, singular, ordinalize"
+    },
+    {
+      "name": "string",
+      "description": "String handling helpers"
+    },
+    {
+      "name": "a_array",
+      "description": "Array handling routines, eg. join, join_prefix, join_post"
+    },
+    {
+      "name": "a_transform",
+      "description": "Tokenize and apply case and/or separator"
+    },
+    {
+      "name": "a_comparison",
+      "description": "Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc."
+    },
+    {
+      "name": "a_inflection",
+      "description": "Inflection handling routines, eg. pluralize, singular, ordinalize"
+    }
+  ]
+}

data/.builders/director/category_director.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class CategoryDirector < KDirector::Directors::BaseDirector
+  def category(name, description)
+    value = {
+      name: name,
+      description: description
+    }
+
+    builder.add(:categories, value: value)
+
+    self
+  end
+
+  def category_file
+    k_builder.target_folders.join(:builder_data, 'categories.json')
+  end
+
+  def save_categories
+    cd(:builder_data)
+    add('categories.json', content: builder.to_json)
+
+    self
+  end
+end

data/.builders/director/cmdlet_builder.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+class CmdletBuilder < KDirector::Builders::ActionsBuilder
+  attr_reader :current_helper
+  # attr_accessor :actions
+  # attr_accessor :last_action
+
+  def initialize
+    super
+
+    dom[:helpers] = []
+    dom[:categories] = []
+    # @actions = []
+    # @last_action = {}
+  end
+
+  def category(name, description)
+    dom[:categories] << {
+      name: name,
+      description: description,
+    }
+  end
+
+  def helpers
+    dom[:helpers]
+  end
+
+  def add_helper
+    @current_helper = new_helper
+    dom[:helpers] << current_helper
+  end
+
+  def helper_setting(name, value)
+    @current_helper[name] = value
+  end
+
+  def add_helper_parameter(name, description, splat: false)
+    parameter = {
+      name: name,
+      description: description,
+      splat: splat
+    }
+
+    @current_helper[:parameters] << parameter
+  end
+
+  def add_helper_example(value)
+    lines = value.split("\n")
+    value = lines.map { |line| "        # #{line.strip}" }.join("\n")
+
+    @current_helper[:examples] << value
+  end
+
+
+  private
+
+  def new_helper
+    {
+      name: nil,
+      description: nil,
+      result: nil,
+      category: nil,
+      category_description: nil,
+      base_class_require: nil,
+      base_class: nil,
+      example_input_value: nil,
+      example_output_value: nil,
+      test_input_value: nil,
+      test_output_value: nil,
+      parameters: [],
+      examples: []
+    }
+  end
+end

data/.builders/director/cmdlet_child.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class HandlebarsHelperChild < KDirector::Directors::ChildDirector
+  def initialize(parent, **opts)
+    super(parent, **opts)
+
+    builder.add_helper
+
+    # defaults = {
+    #   repo_name: opts[:repo_name], # || parent.builder.dom&[:github]&[:repo_name]
+    #   username: opts[:username] || default_github_username, # || parent.builder.dom&[:github]&[:username]
+    #   organization: opts[:organization] # || parent.builder.dom&[:github]&[:organization]
+    # }
+  end
+
+  def name(value)
+    builder.helper_setting(:name, value)
+  end
+
+  def description(value)
+    builder.helper_setting(:description, value)
+  end
+
+  def result(value)
+    builder.helper_setting(:result, value)
+  end
+
+  def category(value)
+    builder.helper_setting(:category, value)
+  end
+
+  def category_description(value)
+    builder.helper_setting(:category_description, value)
+  end
+
+  # def base_class_require(value)
+  #   builder.helper_setting(:base_class_require, value)
+  # end
+
+  # def base_class(value)
+  #   builder.helper_setting(:base_class, value)
+  # end
+
+  # def example_input_value(value)
+  #   builder.helper_setting(:example_input_value, value)
+  # end
+
+  # def example_output_value(value)
+  #   builder.helper_setting(:example_output_value, value)
+  # end
+
+  # def test_input_value(value)
+  #   builder.helper_setting(:test_input_value, value)
+  # end
+
+  # def test_output_value(value)
+  #   builder.helper_setting(:test_output_value, value)
+  # end
+
+  def parameter(name, description, splat: false)
+    builder.add_helper_parameter(name, description, splat: splat)
+  end
+
+  def example(value)
+    builder.add_helper_example(value)
+  end
+end

data/.builders/director/cmdlet_director.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class CmdletDirector < KDirector::Directors::BaseDirector
+  default_builder_type(CmdletBuilder)
+
+  def category(name, description)
+    builder.category(name, description)
+
+    self
+  end
+
+  def helper(**opts, &block)
+    helper = CmdletChild.new(self, **opts)
+    helper.instance_eval(&block) if block_given?
+
+    self
+  end
+
+  def build_helpers
+    builder.helpers.each do |helper|
+      cd(:lib)
+      add("helpers/#{helper[:category]}/#{helper[:name]}.rb", template_file: 'helper.rb', helper: helper)
+
+      cd(:spec)
+      add("helpers/#{helper[:category]}/#{helper[:name]}_spec.rb", template_file: 'helper_spec.rb', helper: helper)
+    end
+
+    self
+  end
+
+  def save_categories
+    cd(:builder_data)
+    add('categories.json', content: JSON.pretty_generate(builder.categories.map(&:to_h)))
+    play_actions
+  end
+end

data/.builders/documents/categories.rb

@@ -11,7 +11,7 @@ def categories
       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 :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"

data/.builders/documents/cmdlets.rb

@@ -0,0 +1,30 @@
+def cmdlets
+  commands.map do |command|
+    category = categories.find { |c| c.name == command.category }
+    
+    log.error("Category '#{command.category}' not found") unless category
+  
+    OpenStruct.new(
+      category: command.category,
+      name: command.name,
+      category_description: category.description,
+      command_description: command.description,
+      ruby: command.ruby,
+      usecases: use_cases
+        .select { |uc| uc.category == command.category && uc.command == command.name }
+        .map { |uc| 
+          OpenStruct.new({
+            category:         uc.category,
+            command:         uc.command,
+            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/commands.rb

@@ -1,31 +1,226 @@
 def commands
-  functions.map do |function|
-    category = categories.find { |c| c.name == function.category }
+  return @commands unless @commands.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 :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 = ','
+        values.join(separator)
+      RUBY
+
+      # row :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 :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
 
-    
-    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 
-          })
-        }
-    )
+      # 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
+  
+  @commands = result.raw_data_struct.rows
 end
-
-def nice_inputs(values)
-  values.map { |value| value.is_a?(String) ? "'#{value}'" : value }.join(', ')
-end
+@commands = nil

data/.builders/generators/20-commands.rb

@@ -0,0 +1,54 @@
+KManager.action :commands do
+  action do
+
+    puts commands.first.function_description
+    # Ruby Gem Bootstrap
+    director = KDirector::Dsls::BasicDsl
+      .init(k_builder,
+        template_base_folder: '',
+        on_exist:                   :skip,                      # %i[skip write compare]
+        on_action:                  :queue                      # %i[queue execute]
+      )
+      .blueprint(
+        active: true,
+        name: :build_commands,
+        description: 'Build Commandlets',
+        on_exist: :write) do
+
+        cd(:lib)
+
+        # builder
+        #   .add_file('FUNCTIONS.md',
+        #             template_file: 'FUNCTIONS.md',
+        #             categories: categories.sort_by { |r| r.name },
+        #             functions: functions.sort_by { |r| [r.category, r.name] },
+        #             on_exist: :write)
+        
+        add('all_commands.rb',
+            template_file: 'all_commands.rb',
+            commands: commands.sort_by { |r| [r.category, r.name] },
+            on_exist: :write)
+
+        cmdlets.each do |cmdlet|
+
+          add("#{cmdlet.category}/#{cmdlet.name}.rb",
+                            cmdlet: cmdlet,
+                            template_file: 'command.rb',
+                            on_exist: :write)
+        end
+            
+      end
+
+    director.play_actions
+    # director.builder.logit
+  end
+end
+
+KManager.opts.app_name                    = 'commands'
+KManager.opts.sleep                       = 2
+KManager.opts.reboot_on_kill              = 0
+KManager.opts.reboot_sleep                = 4
+KManager.opts.exception_style             = :short
+KManager.opts.show.time_taken             = true
+KManager.opts.show.finished               = true
+KManager.opts.show.finished_message       = 'FINISHED :)'

data/.builders/generators/25-categories.rb

@@ -0,0 +1,20 @@
+KManager.action :categories do
+  action do
+
+    CategoryDirector
+      .init(k_builder,
+        on_exist:                   :write,                      # %i[skip write compare]
+        on_action:                  :execute                     # %i[queue execute]
+      )
+      .category(:case               , "Tokenize and apply case and/or separator")
+      .category(:comparison         , "Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.")
+      .category(:inflection         , "Inflection handling routines, eg. pluralize, singular, ordinalize")
+      .category(:string             , "String handling helpers")
+      .category(:a_array            , "Array handling routines, eg. join, join_prefix, join_post")
+      .category(:a_transform        , "Tokenize and apply case and/or separator")
+      .category(:a_comparison       , "Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.")
+      .category(:a_inflection       , "Inflection handling routines, eg. pluralize, singular, ordinalize")
+      .save_categories
+      .category_file
+  end
+end

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+## [0.0.6](https://github.com/klueless-io/cmdlet/compare/v0.0.5...v0.0.6) (2022-07-08)
+
+
+### Bug Fixes
+
+* add tests for configuration ([59a764f](https://github.com/klueless-io/cmdlet/commit/59a764f99f84dbe1c5b1022e8fdc2386fcced92a))
+
+## [0.0.5](https://github.com/klueless-io/cmdlet/compare/v0.0.4...v0.0.5) (2022-07-08)
+
+
+### Bug Fixes
+
+* add string tokenizer ([9d996ff](https://github.com/klueless-io/cmdlet/commit/9d996ff97545617b894d2f29c4500dc44df492b7))
+
+## [0.0.4](https://github.com/klueless-io/cmdlet/compare/v0.0.3...v0.0.4) (2022-07-08)
+
+
+### Bug Fixes
+
+* add basic configuration ([d8ecbb1](https://github.com/klueless-io/cmdlet/commit/d8ecbb17f61600de3b3f5d8987cc132d6e5ba0b2))
+
 ## [0.0.3](https://github.com/klueless-io/cmdlet/compare/v0.0.2...v0.0.3) (2022-07-08)
 
 

data/lib/cmdlet/all_commands.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'cmdlet/array/join'

data/lib/cmdlet/array/join.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# reference: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
+
+module Cmdlet
+  # Array handling routines, eg. join, join_prefix, join_post
+  module Array
+    # Join: join an array of values with separator as a string
+    class Join < Funcky::BaseFunction
+      #
+      # @param [String|Int] value - numeric value
+      # @return [String] ordinal suffix that would be required for a number
+      def parse(value)
+        return '' if value.nil? || !value.is_a?(Array)
+
+        values = value.reject(&:blank?)
+        return '' if value.length.zero?
+
+        separator = ','
+        values.join(separator)
+      end
+    end
+  end
+end

data/lib/cmdlet/configuration.rb

@@ -21,7 +21,7 @@ module Cmdlet
     attr_accessor :padr_char
 
     def initialize
-      # @tokenizer = Funcky::StringTokenizer.new
+      @tokenizer = Cmdlet::StringTokenizer.new
       @padr_count = 30
       @padr_char = ' '
       @padl_count = 30

data/lib/cmdlet/string_tokenizer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string'
+
+module Cmdlet
+  # String tokenizer will clean up a string so that all sorts of formatted strings can be
+  # represented in a consistent fashion
+  class StringTokenizer
+    # Tokenize string
+    # rubocop:disable Metrics/ParameterLists
+    def parse(value,
+              preserve_case: false,
+              compress_prefix_numerals: true,
+              compress_suffix_numerals: true,
+              separator: '-',
+              forced_separator: false)
+      return '' if value.nil?
+
+      # Insert space before any lowercaseUppercase
+      value = value.gsub(/(?<=[a-z])(?=[A-Z])/, ' ')
+
+      # make sure that any numbers followed by space and then some text has the white space removed
+      value = value.gsub(/^(\d*)(\s*)/, '\1') if compress_prefix_numerals
+
+      # Technique1: make sure that trailing space followed by number is compressed
+      # NOTE: named groups don't seem to work with \1, \2 etc.
+      # ex = /(?<space>[\s]*)(?<number>[\d]*)$/
+      # value  =value.sub(ex) { |_| Regexp.last_match[:number] }
+
+      # Technique2: make sure that trailing space followed by number is compressed
+      value = value.gsub(/(\s*)(\d*)$/, '\2') if compress_suffix_numerals
+
+      value = value.parameterize(preserve_case: preserve_case, separator: separator) # (separator: ' ')
+
+      value = value.gsub(/[-_]/, separator) if forced_separator
+
+      value
+    end
+    # rubocop:enable Metrics/ParameterLists
+  end
+end

data/lib/cmdlet/version.rb

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

data/lib/cmdlet.rb

@@ -4,6 +4,7 @@
 require 'k_config'
 require_relative 'cmdlet/version'
 require_relative 'cmdlet/configuration'
+require_relative 'cmdlet/string_tokenizer'
 
 module Cmdlet
   # raise Cmdlet::Error, 'Sample message'

data/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "cmdlet",
-  "version": "0.0.4",
+  "version": "0.0.7",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "cmdlet",
-      "version": "0.0.4",
+      "version": "0.0.7",
       "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.4",
+  "version": "0.0.7",
   "description": "Cmdlet provides a set of functions (wrapped in the command pattern) that perform simple actions",
   "scripts": {
     "release": "semantic-release"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: cmdlet
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.7
 platform: ruby
 authors:
 - David Cruwys
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-07-08 00:00:00.000000000 Z
+date: 2022-07-09 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_config
   requirement: !ruby/object:Gem::Requirement
@@ -32,15 +46,25 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".builders/.templates/FUNCTIONS.MD"
+- ".builders/.templates/all_commands.rb"
+- ".builders/.templates/command.rb"
+- ".builders/.templates/command_spec.rb"
 - ".builders/_.rb"
 - ".builders/boot.rb"
-- ".builders/documents/_.rb"
+- ".builders/data/categories.json"
+- ".builders/director/category_director.rb"
+- ".builders/director/cmdlet_builder.rb"
+- ".builders/director/cmdlet_child.rb"
+- ".builders/director/cmdlet_director.rb"
 - ".builders/documents/categories.rb"
+- ".builders/documents/cmdlets.rb"
 - ".builders/documents/commands.rb"
-- ".builders/documents/functions.rb"
 - ".builders/documents/use_cases.rb"
 - ".builders/documents/x_functions.rb"
 - ".builders/generators/01-bootstrap.rb"
+- ".builders/generators/20-commands.rb"
+- ".builders/generators/25-categories.rb"
 - ".releaserc.json"
 - ".rspec"
 - ".rubocop.yml"
@@ -54,7 +78,10 @@ files:
 - bin/console
 - bin/setup
 - lib/cmdlet.rb
+- lib/cmdlet/all_commands.rb
+- lib/cmdlet/array/join.rb
 - lib/cmdlet/configuration.rb
+- lib/cmdlet/string_tokenizer.rb
 - lib/cmdlet/version.rb
 - package-lock.json
 - package.json
@@ -63,6 +90,9 @@ homepage: http://appydave.com/gems/cmdlet
 licenses:
 - MIT
 metadata:
+  homepage_uri: http://appydave.com/gems/cmdlet
+  source_code_uri: https://github.com/klueless-io/cmdlet
+  changelog_uri: https://github.com/klueless-io/cmdlet/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []

data/.builders/documents/_.rb

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

data/.builders/documents/functions.rb

@@ -1,226 +0,0 @@
-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