cmdlet 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc4888cd594af0dd224a836be55e28d9b6cdf153ac89e770807d412b14d11982
-  data.tar.gz: 00b2044a9a53f53afbe109a443aabd7cc38db54782fd1a1eebfbdc563db3de7c
+  metadata.gz: cbd35f78dbd459eac65f0df1fd2f6aefc16b560b3083140a9ea092dc6cf359ec
+  data.tar.gz: 27fff2ef08e9df32b43b5bf06d72755893e3a701af8057d55c0379f6ebe82226
 SHA512:
-  metadata.gz: f7470c8c5cc637bfc48aa1e5d9a63d73748831e71d323cdf3a09d2cb1b5b0e8e40970300072eafbbe00976334d7021e3e22ce66f5626b4983faa2d02f5e4ca70
-  data.tar.gz: e04137866c533b774510d0964be0a27f98110c23237da9d55b8c560d371f1a32d55e8e2af67799b0f58b3240434b1fb7b46f40915cb1baacf4adcfb5f037a496
+  metadata.gz: cf6ea403db6da89cf2f82957773fe648f7eb8883acd112524d44149fb4f8067409b3d17e8240d13b6ab1059883d86ecbadc4efb61bbbec4722cd0bc6620baee6
+  data.tar.gz: 91153e6f0c1aec787f555ff44afe2469328208bd11f8d8857a05d4da18a7f54cdc00dd12e2a6c774c1d2ec2cd2870a5e23723bc08d9783709fd75fa526d40a35

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

@@ -0,0 +1,313 @@
+{
+  "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": "sentence",
+      "description": "Sentence case the characters in the given 'string'",
+      "result": "value converted to sentence 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).titleize\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/generators/cmdlets/case.rb

@@ -0,0 +1,184 @@
+# 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 :sentence
+        description           "Sentence case the characters in the given 'string'"
+        result                'value converted to sentence 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 :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/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [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,20 @@
 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/sentence'
+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/sentence.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Tokenize and apply case and/or separator
+  module Case
+    # Sentence: Sentence case the characters in the given 'string'
+    class Sentence < Cmdlet::BaseCmdlet
+      #
+      # @param [String|Int] value - value - to be converted
+      # @return [String] value converted to sentence 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/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.2.1'
 end

data/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "cmdlet",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "cmdlet",
-      "version": "0.2.0",
+      "version": "0.2.1",
       "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.2.1",
   "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.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - David Cruwys
@@ -54,6 +54,7 @@ files:
 - ".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"
@@ -71,6 +72,7 @@ files:
 - ".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 +94,20 @@ 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/sentence.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