cmdlet 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc4888cd594af0dd224a836be55e28d9b6cdf153ac89e770807d412b14d11982
-  data.tar.gz: 00b2044a9a53f53afbe109a443aabd7cc38db54782fd1a1eebfbdc563db3de7c
+  metadata.gz: ee471d453193e6c2530ef1728dd97225d9bc1e02f5fefe725e7d1ec4b2d37bff
+  data.tar.gz: c661a29c3a9493d65724c704d2adf0b925236f98179d685067733b7bca0173bf
 SHA512:
-  metadata.gz: f7470c8c5cc637bfc48aa1e5d9a63d73748831e71d323cdf3a09d2cb1b5b0e8e40970300072eafbbe00976334d7021e3e22ce66f5626b4983faa2d02f5e4ca70
-  data.tar.gz: e04137866c533b774510d0964be0a27f98110c23237da9d55b8c560d371f1a32d55e8e2af67799b0f58b3240434b1fb7b46f40915cb1baacf4adcfb5f037a496
+  metadata.gz: bc94edaa20e1dc9ab4ce5b1fc4ec20479fa3f3744ca34ca0c878835d00df85a4fdf7fec4efbf412d26239b98387fec5f1402226278bed4ecea70f8ec0c4db647
+  data.tar.gz: 1cb05dc779c98bb1bed4c86cd7da6755b3e5b864ba9409e5605476ac9e9efe544d2d66a3f48936d358227d2d12a11e215100b2ce169439edef5f940a8d7eee7d

data/.builders/.templates/handlebars_helper.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Handlebarsjs
+  module Helpers
+    # {{cmdlet.category_description}}
+    module {{camel cmdlet.category}}
+      # {{camel cmdlet.name}}: {{cmdlet.description}}
+      class {{camel cmdlet.name}} < Handlebarsjs::BaseHelper
+        register_cmdlet(Cmdlet::{{camel cmdlet.category}}::{{camel cmdlet.name}})
+
+        def to_proc
+          ->({{#each cmdlet.parameters}}{{#if ./splat}}{{./splat}}{{/if}}{{./name}}{{#if ./default}} = {{{./default}}}{{/if}}{{#if @last}}{{^}}, {{/if}}{{/each}}, _opts) { wrapper(cmdlet.call({{#each cmdlet.parameters}}{{#if ./splat}}{{./splat}}{{/if}}{{./name}}{{#if @last}}{{^}}, {{/if}}{{/each}})) }
+        end
+      end
+    end
+  end
+end

data/.builders/.templates/handlebars_helper_require_all.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+{{#each cmdlets}}
+require_relative 'handlebarsjs/helpers/{{category}}/{{name}}'
+{{/each}}

data/.builders/.templates/handlebars_helper_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# {{camel cmdlet.name}}: {{cmdlet.description}}
+RSpec.describe Handlebarsjs::Helpers::{{camel cmdlet.category}}::{{camel cmdlet.name}} do
+  let(:helper_name) { :{{cmdlet.name}} }
+  let(:helper) { described_class.new }
+  let(:handlebars) { Handlebarsjs::Handlebars.new }
+  
+  before { handlebars.handlebars_snapshot.add_helper(helper_name, helper) }
+
+  describe '#process_template' do
+    subject { handlebars.process_template(template, data).squish }
+
+    let(:lhs) { nil }
+    let(:rhs) { nil }
+    let(:data) { { lhs: lhs, rhs: rhs } }
+
+    let(:template) do
+      <<~TEXT.chomp
+        {{#if (and lhs rhs)}}
+        {{^}}
+        {{/if}}
+      TEXT
+    end
+  end
+end

data/.builders/boot.rb

@@ -46,6 +46,7 @@ KConfig.configure(CONFIG_KEY) do |config|
   builder_folder    = Dir.pwd
   base_folder       = File.expand_path('../', builder_folder)
   global_template   = File.expand_path('~/dev/kgems/k_templates/templates')
+  handlebars_folder = File.expand_path('~/dev/kgems/handlebarsjs/')
 
   config.template_folders.add(:global_template    , global_template)
   config.template_folders.add(:template           , File.expand_path('.templates', Dir.pwd))
@@ -55,6 +56,9 @@ KConfig.configure(CONFIG_KEY) do |config|
   config.target_folders.add(:spec                 , :app, 'spec/cmdlet')
   config.target_folders.add(:builder              , builder_folder)
   config.target_folders.add(:builder_data         , :builder, 'data')
+  config.target_folders.add(:handlebars           , handlebars_folder)
+  config.target_folders.add(:handlebars_lib       , :handlebars, 'lib')
+  config.target_folders.add(:handlebars_spec      , :handlebars, 'spec')
 end
 
 KConfig.configuration(CONFIG_KEY).debug

data/.builders/data/cmdlets/case.json

@@ -0,0 +1,291 @@
+{
+  "category_key": "case",
+  "cmdlets": [
+    {
+      "name": "back_slash",
+      "description": "Convert to back slash notation",
+      "result": "value converted to back_slash case",
+      "category": "case",
+      "category_description": "Tokenize and apply case and/or separator",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - to be converted",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          tokenizer.parse(value, preserve_case: true, separator: '\\\\')\n"
+    },
+    {
+      "name": "camel",
+      "description": "Camel case the characters in the given 'string'",
+      "result": "value converted to camel case",
+      "category": "case",
+      "category_description": "Tokenize and apply case and/or separator",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - to be converted",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          tokenizer.parse(value).underscore.camelize\n"
+    },
+    {
+      "name": "constant",
+      "description": "Constant case the characters in the given 'string'",
+      "result": "value converted to constant case",
+      "category": "case",
+      "category_description": "Tokenize and apply case and/or separator",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - to be converted",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          tokenizer.parse(value, separator: '_').upcase\n"
+    },
+    {
+      "name": "dash",
+      "description": "Dash case the characters in the given 'string'",
+      "result": "value converted to dash case",
+      "category": "case",
+      "category_description": "Tokenize and apply case and/or separator",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - to be converted",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          tokenizer.parse(value)\n"
+    },
+    {
+      "name": "dot",
+      "description": "Dot case the characters in the given 'string'",
+      "result": "value converted to dot case",
+      "category": "case",
+      "category_description": "Tokenize and apply case and/or separator",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - to be converted",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          tokenizer.parse(value, separator: '.')\n"
+    },
+    {
+      "name": "double_colon",
+      "description": "Double colon case the characters in the given 'string'",
+      "result": "value converted to double_colon case",
+      "category": "case",
+      "category_description": "Tokenize and apply case and/or separator",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - to be converted",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          tokenizer.parse(value, preserve_case: true, separator: '::')\n"
+    },
+    {
+      "name": "human",
+      "description": "Human case the characters in the given 'string'",
+      "result": "value converted to human case",
+      "category": "case",
+      "category_description": "Tokenize and apply case and/or separator",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - to be converted",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          tokenizer.parse(value,\n            separator: ' ',\n            preserve_case: true,\n            compress_prefix_numerals: false,\n            compress_suffix_numerals: false).humanize\n"
+    },
+    {
+      "name": "lamel",
+      "description": "Lower camel case the characters in the given 'string'",
+      "result": "value converted to lower camel case",
+      "category": "case",
+      "category_description": "Tokenize and apply case and/or separator",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - to be converted",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          tokenizer.parse(value, separator: '_').camelize(:lower)\n"
+    },
+    {
+      "name": "lower",
+      "description": "Lower case the characters in the given 'string'",
+      "result": "value converted to lower case",
+      "category": "case",
+      "category_description": "Tokenize and apply case and/or separator",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - to be converted",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          return '' if value.nil?\n\n          value.downcase\n"
+    },
+    {
+      "name": "slash",
+      "description": "Slash case the characters in the given 'string'",
+      "result": "value converted to slash case",
+      "category": "case",
+      "category_description": "Tokenize and apply case and/or separator",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - to be converted",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          tokenizer.parse(value, preserve_case: true, separator: '/')\n"
+    },
+    {
+      "name": "snake",
+      "description": "Snake case the characters in the given 'string'",
+      "result": "value converted to snake case",
+      "category": "case",
+      "category_description": "Tokenize and apply case and/or separator",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - to be converted",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          tokenizer.parse(value, separator: '_', forced_separator: true)\n"
+    },
+    {
+      "name": "title",
+      "description": "Title case the characters in the given 'string'",
+      "result": "value converted to title case",
+      "category": "case",
+      "category_description": "Tokenize and apply case and/or separator",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - to be converted",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "        tokenizer.parse(value,\n          separator: ' ',\n          preserve_case: true,\n          compress_prefix_numerals: false,\n          compress_suffix_numerals: false)\n        .titleize\n"
+    },
+    {
+      "name": "upper",
+      "description": "Upper case the characters in the given 'string'",
+      "result": "value converted to upper case",
+      "category": "case",
+      "category_description": "Tokenize and apply case and/or separator",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - to be converted",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          return '' if value.nil?\n\n          value.upcase\n"
+    }
+  ]
+}

data/.builders/director/category_director.rb

@@ -31,7 +31,12 @@ class CategoryDirector < KDirector::Directors::BaseDirector
   def generate_require_all_cmdlets
     cd(:lib)
     add('_.rb',
-      template_file: 'require_all_cmdlets.rb',
+      template_file: 'cmdlets_require_all.rb',
+      cmdlets: data_access.cmdlet.all_cmdlets)
+
+    cd(:handlebars_lib)
+    add('_.rb', 
+      template_file: 'handlebars_helper_require_all.rb',
       cmdlets: data_access.cmdlet.all_cmdlets)
 
   end

data/.builders/director/cmdlet_director.rb

@@ -32,12 +32,20 @@ class CmdletDirector < KDirector::Directors::BaseDirector
     builder.cmdlets.each do |cmdlet|
       cmdlet_file = "#{cmdlet[:category]}/#{cmdlet[:name]}.rb"
       cmdlet_spec_file = "#{cmdlet[:category]}/#{cmdlet[:name]}_spec.rb"
+      handlebars_file = "handlebarsjs/helpers/#{cmdlet[:category]}/#{cmdlet[:name]}.rb"
+      handlebars_spec_file = "handlebarsjs/helpers/#{cmdlet[:category]}/#{cmdlet[:name]}_spec.rb"
 
       cd(:lib)
       add(cmdlet_file, template_file: 'cmdlet.rb', cmdlet: cmdlet)
 
       cd(:spec)
       add(cmdlet_spec_file, template_file: 'cmdlet_spec.rb', cmdlet: cmdlet, on_exist: :skip)
+
+      cd(:handlebars_lib)
+      add(handlebars_file, template_file: 'handlebars_helper.rb', cmdlet: cmdlet)
+
+      cd(:handlebars_spec)
+      add(handlebars_spec_file, template_file: 'handlebars_helper_spec.rb', cmdlet: cmdlet, on_exist: :skip)
     end
 
     self
@@ -48,6 +56,10 @@ class CmdletDirector < KDirector::Directors::BaseDirector
       k_builder.run_cop('**/*.rb', fix_unsafe: true)
     end
 
+    Dir.chdir(k_builder.target_folders.get(:handlebars)) do
+      k_builder.run_cop('**/*.rb', fix_unsafe: true)
+    end
+
     self
   end
 

data/.builders/generators/cmdlets/case.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+KManager.action :case_commands do
+  action do
+    CmdletDirector
+      .init(k_builder, category: :case)
+      .cmdlet do
+        name :back_slash
+        description           'Convert to back slash notation'
+        result                'value converted to back_slash case'
+
+        parameter             :value, 'value - to be converted', param_type: 'String|Int'
+
+        ruby <<-'RUBY'
+          tokenizer.parse(value, preserve_case: true, separator: '\\')
+        RUBY
+      end
+      .cmdlet do
+        name :camel
+        description           "Camel case the characters in the given 'string'"
+        result                'value converted to camel case'
+
+        parameter             :value, 'value - to be converted', param_type: 'String|Int'
+
+        ruby <<-'RUBY'
+          tokenizer.parse(value).underscore.camelize
+        RUBY
+      end
+      .cmdlet do
+        name :constant
+        description           "Constant case the characters in the given 'string'"
+        result                'value converted to constant case'
+
+        parameter             :value, 'value - to be converted', param_type: 'String|Int'
+
+        ruby <<-'RUBY'
+          tokenizer.parse(value, separator: '_').upcase
+        RUBY
+      end
+      .cmdlet do
+        name :dash
+        description           "Dash case the characters in the given 'string'"
+        result                'value converted to dash case'
+
+        parameter             :value, 'value - to be converted', param_type: 'String|Int'
+
+        ruby <<-'RUBY'
+          tokenizer.parse(value)
+        RUBY
+      end
+      .cmdlet do
+        name :dot
+        description           "Dot case the characters in the given 'string'"
+        result                'value converted to dot case'
+
+        parameter             :value, 'value - to be converted', param_type: 'String|Int'
+
+        ruby <<-'RUBY'
+          tokenizer.parse(value, separator: '.')
+        RUBY
+      end
+      .cmdlet do
+        name :double_colon
+        description           "Double colon case the characters in the given 'string'"
+        result                'value converted to double_colon case'
+
+        parameter             :value, 'value - to be converted', param_type: 'String|Int'
+
+        ruby <<-'RUBY'
+          tokenizer.parse(value, preserve_case: true, separator: '::')
+        RUBY
+      end
+      .cmdlet do
+        name :human
+        description           "Human case the characters in the given 'string'"
+        result                'value converted to human case'
+
+        parameter             :value, 'value - to be converted', param_type: 'String|Int'
+
+        ruby <<-'RUBY'
+          tokenizer.parse(value,
+            separator: ' ',
+            preserve_case: true,
+            compress_prefix_numerals: false,
+            compress_suffix_numerals: false).humanize
+        RUBY
+      end
+      .cmdlet do
+        name :lamel
+        description           "Lower camel case the characters in the given 'string'"
+        result                'value converted to lower camel case'
+
+        parameter             :value, 'value - to be converted', param_type: 'String|Int'
+
+        ruby <<-'RUBY'
+          tokenizer.parse(value, separator: '_').camelize(:lower)
+        RUBY
+      end
+      .cmdlet do
+        name :lower
+        description           "Lower case the characters in the given 'string'"
+        result                'value converted to lower case'
+
+        parameter             :value, 'value - to be converted', param_type: 'String|Int'
+
+        ruby <<-'RUBY'
+          return '' if value.nil?
+
+          value.downcase
+        RUBY
+      end
+      .cmdlet do
+        name :slash
+        description           "Slash case the characters in the given 'string'"
+        result                'value converted to slash case'
+
+        parameter             :value, 'value - to be converted', param_type: 'String|Int'
+
+        ruby <<-'RUBY'
+          tokenizer.parse(value, preserve_case: true, separator: '/')
+        RUBY
+      end
+      .cmdlet do
+        name :snake
+        description           "Snake case the characters in the given 'string'"
+        result                'value converted to snake case'
+
+        parameter             :value, 'value - to be converted', param_type: 'String|Int'
+
+        ruby <<-'RUBY'
+          tokenizer.parse(value, separator: '_', forced_separator: true)
+        RUBY
+      end
+      .cmdlet do
+        name :title
+        description           "Title case the characters in the given 'string'"
+        result                'value converted to title case'
+
+        parameter             :value, 'value - to be converted', param_type: 'String|Int'
+
+        ruby <<-'RUBY'
+        tokenizer.parse(value,
+          separator: ' ',
+          preserve_case: true,
+          compress_prefix_numerals: false,
+          compress_suffix_numerals: false)
+        .titleize
+      RUBY
+      end
+      .cmdlet do
+        name :upper
+        description           "Upper case the characters in the given 'string'"
+        result                'value converted to upper case'
+
+        parameter             :value, 'value - to be converted', param_type: 'String|Int'
+
+        ruby <<-'RUBY'
+          return '' if value.nil?
+
+          value.upcase
+        RUBY
+      end
+      .generate
+      .debug
+  end
+end
+
+# format_as
+# upper

data/.builders/generators/cmdlets/comparison.rb

@@ -11,7 +11,7 @@ KManager.action :comparison_commands do
 
         parameter             :values, 'list of values (via *splat) to be checked via AND condition', splat: '*', param_type: 'Object'
 
-        ruby <<-RUBY
+        ruby <<-RUBY 
           values.all? { |value| value }
         RUBY
       end

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+# [0.3.0](https://github.com/klueless-io/cmdlet/compare/v0.2.1...v0.3.0) (2022-07-11)
+
+
+### Features
+
+* update handlebars templates ([599246d](https://github.com/klueless-io/cmdlet/commit/599246d9521381106524c263ccc1c157f093389d))
+
+## [0.2.1](https://github.com/klueless-io/cmdlet/compare/v0.2.0...v0.2.1) (2022-07-10)
+
+
+### Bug Fixes
+
+* add case commandlets ([b269f2a](https://github.com/klueless-io/cmdlet/commit/b269f2a770dd698119f360d47756b47bd5b57516))
+
+# [0.2.0](https://github.com/klueless-io/cmdlet/compare/v0.1.2...v0.2.0) (2022-07-10)
+
+
+### Features
+
+* add inflection cmdlets ([55bb73f](https://github.com/klueless-io/cmdlet/commit/55bb73fe3420096a1d4edd85d207529507c088db))
+
 ## [0.1.2](https://github.com/klueless-io/cmdlet/compare/v0.1.1...v0.1.2) (2022-07-10)
 
 

data/lib/cmdlet/_.rb

@@ -3,6 +3,19 @@
 require_relative 'array/join'
 require_relative 'array/join_post'
 require_relative 'array/join_pre'
+require_relative 'case/back_slash'
+require_relative 'case/camel'
+require_relative 'case/constant'
+require_relative 'case/dash'
+require_relative 'case/dot'
+require_relative 'case/double_colon'
+require_relative 'case/human'
+require_relative 'case/lamel'
+require_relative 'case/lower'
+require_relative 'case/slash'
+require_relative 'case/snake'
+require_relative 'case/title'
+require_relative 'case/upper'
 require_relative 'comparison/and'
 require_relative 'comparison/default'
 require_relative 'comparison/eq'

data/lib/cmdlet/base_cmdlet.rb

@@ -11,7 +11,7 @@ module Cmdlet
     # all sorts of case formatted strings can be
     # represented in a consistent fashion
     def tokenizer
-      @_tokenizer ||= Funcky.configuration.tokenizer
+      @_tokenizer ||= KConfig.configuration.cmdlet.tokenizer
     end
   end
 end

data/lib/cmdlet/case/back_slash.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Tokenize and apply case and/or separator
+  module Case
+    # BackSlash: Convert to back slash notation
+    class BackSlash < Cmdlet::BaseCmdlet
+      #
+      # @param [String|Int] value - value - to be converted
+      # @return [String] value converted to back_slash case
+      def call(value)
+        tokenizer.parse(value, preserve_case: true, separator: '\\')
+      end
+    end
+  end
+end

data/lib/cmdlet/case/camel.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Tokenize and apply case and/or separator
+  module Case
+    # Camel: Camel case the characters in the given 'string'
+    class Camel < Cmdlet::BaseCmdlet
+      #
+      # @param [String|Int] value - value - to be converted
+      # @return [String] value converted to camel case
+      def call(value)
+        tokenizer.parse(value).underscore.camelize
+      end
+    end
+  end
+end

data/lib/cmdlet/case/constant.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Tokenize and apply case and/or separator
+  module Case
+    # Constant: Constant case the characters in the given 'string'
+    class Constant < Cmdlet::BaseCmdlet
+      #
+      # @param [String|Int] value - value - to be converted
+      # @return [String] value converted to constant case
+      def call(value)
+        tokenizer.parse(value, separator: '_').upcase
+      end
+    end
+  end
+end

data/lib/cmdlet/case/dash.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Tokenize and apply case and/or separator
+  module Case
+    # Dash: Dash case the characters in the given 'string'
+    class Dash < Cmdlet::BaseCmdlet
+      #
+      # @param [String|Int] value - value - to be converted
+      # @return [String] value converted to dash case
+      def call(value)
+        tokenizer.parse(value)
+      end
+    end
+  end
+end

data/lib/cmdlet/case/dot.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Tokenize and apply case and/or separator
+  module Case
+    # Dot: Dot case the characters in the given 'string'
+    class Dot < Cmdlet::BaseCmdlet
+      #
+      # @param [String|Int] value - value - to be converted
+      # @return [String] value converted to dot case
+      def call(value)
+        tokenizer.parse(value, separator: '.')
+      end
+    end
+  end
+end

data/lib/cmdlet/case/double_colon.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Tokenize and apply case and/or separator
+  module Case
+    # DoubleColon: Double colon case the characters in the given 'string'
+    class DoubleColon < Cmdlet::BaseCmdlet
+      #
+      # @param [String|Int] value - value - to be converted
+      # @return [String] value converted to double_colon case
+      def call(value)
+        tokenizer.parse(value, preserve_case: true, separator: '::')
+      end
+    end
+  end
+end

data/lib/cmdlet/case/human.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Tokenize and apply case and/or separator
+  module Case
+    # Human: Human case the characters in the given 'string'
+    class Human < Cmdlet::BaseCmdlet
+      #
+      # @param [String|Int] value - value - to be converted
+      # @return [String] value converted to human case
+      def call(value)
+        tokenizer.parse(value,
+                        separator: ' ',
+                        preserve_case: true,
+                        compress_prefix_numerals: false,
+                        compress_suffix_numerals: false).humanize
+      end
+    end
+  end
+end

data/lib/cmdlet/case/lamel.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Tokenize and apply case and/or separator
+  module Case
+    # Lamel: Lower camel case the characters in the given 'string'
+    class Lamel < Cmdlet::BaseCmdlet
+      #
+      # @param [String|Int] value - value - to be converted
+      # @return [String] value converted to lower camel case
+      def call(value)
+        tokenizer.parse(value, separator: '_').camelize(:lower)
+      end
+    end
+  end
+end

data/lib/cmdlet/case/lower.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Tokenize and apply case and/or separator
+  module Case
+    # Lower: Lower case the characters in the given 'string'
+    class Lower < Cmdlet::BaseCmdlet
+      #
+      # @param [String|Int] value - value - to be converted
+      # @return [String] value converted to lower case
+      def call(value)
+        return '' if value.nil?
+
+        value.downcase
+      end
+    end
+  end
+end

data/lib/cmdlet/case/slash.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Tokenize and apply case and/or separator
+  module Case
+    # Slash: Slash case the characters in the given 'string'
+    class Slash < Cmdlet::BaseCmdlet
+      #
+      # @param [String|Int] value - value - to be converted
+      # @return [String] value converted to slash case
+      def call(value)
+        tokenizer.parse(value, preserve_case: true, separator: '/')
+      end
+    end
+  end
+end

data/lib/cmdlet/case/snake.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Tokenize and apply case and/or separator
+  module Case
+    # Snake: Snake case the characters in the given 'string'
+    class Snake < Cmdlet::BaseCmdlet
+      #
+      # @param [String|Int] value - value - to be converted
+      # @return [String] value converted to snake case
+      def call(value)
+        tokenizer.parse(value, separator: '_', forced_separator: true)
+      end
+    end
+  end
+end

data/lib/cmdlet/case/title.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Tokenize and apply case and/or separator
+  module Case
+    # Title: Title case the characters in the given 'string'
+    class Title < Cmdlet::BaseCmdlet
+      #
+      # @param [String|Int] value - value - to be converted
+      # @return [String] value converted to title case
+      def call(value)
+        tokenizer.parse(value,
+                        separator: ' ',
+                        preserve_case: true,
+                        compress_prefix_numerals: false,
+                        compress_suffix_numerals: false)
+                 .titleize
+      end
+    end
+  end
+end

data/lib/cmdlet/case/upper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Tokenize and apply case and/or separator
+  module Case
+    # Upper: Upper case the characters in the given 'string'
+    class Upper < Cmdlet::BaseCmdlet
+      #
+      # @param [String|Int] value - value - to be converted
+      # @return [String] value converted to upper case
+      def call(value)
+        return '' if value.nil?
+
+        value.upcase
+      end
+    end
+  end
+end

data/lib/cmdlet/version.rb

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

data/package-lock.json

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cmdlet
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - David Cruwys
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-07-10 00:00:00.000000000 Z
+date: 2022-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -49,11 +49,15 @@ files:
 - ".builders/.templates/FUNCTIONS.MD"
 - ".builders/.templates/cmdlet.rb"
 - ".builders/.templates/cmdlet_spec.rb"
-- ".builders/.templates/require_all_cmdlets.rb"
+- ".builders/.templates/cmdlets_require_all.rb"
+- ".builders/.templates/handlebars_helper.rb"
+- ".builders/.templates/handlebars_helper_require_all.rb"
+- ".builders/.templates/handlebars_helper_spec.rb"
 - ".builders/_.rb"
 - ".builders/boot.rb"
 - ".builders/data/categories.json"
 - ".builders/data/cmdlets/array.json"
+- ".builders/data/cmdlets/case.json"
 - ".builders/data/cmdlets/comparison.json"
 - ".builders/data/cmdlets/inflection.json"
 - ".builders/director/category_builder.rb"
@@ -64,13 +68,13 @@ files:
 - ".builders/director/cmdlet_dao.rb"
 - ".builders/director/cmdlet_director.rb"
 - ".builders/director/dao.rb"
-- ".builders/documents/commands.rb"
 - ".builders/documents/use_cases.rb"
 - ".builders/documents/x_functions.rb"
 - ".builders/generators/01-bootstrap.rb"
 - ".builders/generators/20-categories.rb"
 - ".builders/generators/30-commands-bak.rb"
 - ".builders/generators/cmdlets/array.rb"
+- ".builders/generators/cmdlets/case.rb"
 - ".builders/generators/cmdlets/comparison.rb"
 - ".builders/generators/cmdlets/inflection.rb"
 - ".releaserc.json"
@@ -92,6 +96,19 @@ files:
 - lib/cmdlet/array/join_post.rb
 - lib/cmdlet/array/join_pre.rb
 - lib/cmdlet/base_cmdlet.rb
+- lib/cmdlet/case/back_slash.rb
+- lib/cmdlet/case/camel.rb
+- lib/cmdlet/case/constant.rb
+- lib/cmdlet/case/dash.rb
+- lib/cmdlet/case/dot.rb
+- lib/cmdlet/case/double_colon.rb
+- lib/cmdlet/case/human.rb
+- lib/cmdlet/case/lamel.rb
+- lib/cmdlet/case/lower.rb
+- lib/cmdlet/case/slash.rb
+- lib/cmdlet/case/snake.rb
+- lib/cmdlet/case/title.rb
+- lib/cmdlet/case/upper.rb
 - lib/cmdlet/comparison/and.rb
 - lib/cmdlet/comparison/default.rb
 - lib/cmdlet/comparison/eq.rb

data/.builders/documents/commands.rb

@@ -1,225 +0,0 @@
-# frozen_string_literal: true
-
-def commands
-  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
-
-      # 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
-@commands = nil