cmdlet 0.0.7 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49865609277b82bf27cc7275b38f0830109e2228b8ab3629ca1774d07b85f834
-  data.tar.gz: 7d6c2c92910fc466f8f0d3e04ebb4356dfb070c17e553a3e573c60e946648032
+  metadata.gz: cbd35f78dbd459eac65f0df1fd2f6aefc16b560b3083140a9ea092dc6cf359ec
+  data.tar.gz: 27fff2ef08e9df32b43b5bf06d72755893e3a701af8057d55c0379f6ebe82226
 SHA512:
-  metadata.gz: d7bd4e1e6364146d104a96bd66425df76f3bd164b350f1b3328f046cc8c8e2b6f2d65eec9dacd18c7ce510e064846f10b0ba2a49315089f6ff0235e494b34387
-  data.tar.gz: e0ddc16a51d5c16957ac2241098de2f1a7a0de777f59621d8398da8e61172ae07c9ea796971e48ce024a646eee0c6b29cd1fe93fde4c6840c0d41b497c63da14
+  metadata.gz: cf6ea403db6da89cf2f82957773fe648f7eb8883acd112524d44149fb4f8067409b3d17e8240d13b6ab1059883d86ecbadc4efb61bbbec4722cd0bc6620baee6
+  data.tar.gz: 91153e6f0c1aec787f555ff44afe2469328208bd11f8d8857a05d4da18a7f54cdc00dd12e2a6c774c1d2ec2cd2870a5e23723bc08d9783709fd75fa526d40a35

data/.builders/.templates/cmdlet.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # {{cmdlet.category_description}}
+  module {{camel cmdlet.category}}
+    # {{camel cmdlet.name}}: {{cmdlet.description}}
+    class {{camel cmdlet.name}} < Cmdlet::BaseCmdlet
+      {{#each cmdlet.usecases}}
+      # @example
+      #
+      #   puts {{camel ./function}}.new.call({{{nice_inputs}}})
+      #
+      #   {{expected_output}}
+      #
+      {{/each}}
+      #
+      {{#each cmdlet.parameters}}
+      # @param [{{./param_type}}] {{./name}} - {{./description}}
+      {{/each}}
+      # @return [String] {{cmdlet.result}}
+      def call({{#each cmdlet.parameters}}{{#if ./splat}}{{./splat}}{{/if}}{{./name}}{{#if ./default}} = {{{./default}}}{{/if}}{{#if @last}}{{^}}, {{/if}}{{/each}})
+{{{cmdlet.ruby}}}
+      end
+    end
+  end
+end

data/.builders/.templates/{command_spec.rb → cmdlet_spec.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-# {{camel command.name}}: {{command.function_description}}
-RSpec.describe Funcky::{{camel command.category}}::{{camel command.name}} do
+# {{camel cmdlet.name}}: {{cmdlet.description}}
+RSpec.describe Cmdlet::{{camel cmdlet.category}}::{{camel cmdlet.name}} do
   let(:instance) { described_class.new }
   
   describe 'initialize' do
@@ -10,8 +10,8 @@ RSpec.describe Funcky::{{camel command.category}}::{{camel command.name}} do
     it { is_expected.not_to be_nil }
   end
 
-  describe '#parse' do
-    subject { instance.parse(value) }
+  describe '#call' do
+    subject { instance.call(value) }
 
     let(:value) { nil }
 

data/.builders/.templates/require_all_cmdlets.rb

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

data/.builders/_.rb

@@ -1,4 +1,10 @@
-# require_relative './documents/_'
+# frozen_string_literal: true
+
+require_relative './director/category_dao'
+require_relative './director/cmdlet_dao'
+require_relative './director/dao'
+
+require_relative './director/category_builder'
 require_relative './director/category_director'
 require_relative './director/cmdlet_builder'
 require_relative './director/cmdlet_director'

data/.builders/boot.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Boot Sequence
 
 include KLog::Logging

data/.builders/data/categories.json

@@ -17,20 +17,12 @@
       "description": "String handling helpers"
     },
     {
-      "name": "a_array",
+      "name": "array",
       "description": "Array handling routines, eg. join, join_prefix, join_post"
     },
     {
-      "name": "a_transform",
+      "name": "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/data/cmdlets/array.json

@@ -0,0 +1,121 @@
+{
+  "category_key": "array",
+  "cmdlets": [
+    {
+      "name": "join",
+      "description": "join an array of values with separator as a string",
+      "result": "new String formed by joining the array elements with seperator",
+      "category": "array",
+      "category_description": "Array handling routines, eg. join, join_prefix, join_post",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "values",
+          "description": "array of values to join",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        },
+        {
+          "name": "separator",
+          "description": "separator between values, defaults to comma",
+          "splat": null,
+          "default": "','",
+          "param_type": "String"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          return false if values.nil? || values.length == 0\n          values = values.reject(&:blank?)\n          return '' if values.length.zero?\n\n          values.join(separator)\n"
+    },
+    {
+      "name": "join_pre",
+      "description": "join an array of values with separator as a string and using the separator at the beginning of string",
+      "result": null,
+      "category": "array",
+      "category_description": "Array handling routines, eg. join, join_prefix, join_post",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "values",
+          "description": "array of values to join",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        },
+        {
+          "name": "separator",
+          "description": "separator between values, defaults to comma",
+          "splat": null,
+          "default": "','",
+          "param_type": "String"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          return '' if values.nil? || !values.is_a?(::Array)\n          values = values.reject(&:blank?)\n          return '' if values.length.zero?\n\n          \"#{separator}#{values.join(separator)}\"\n"
+    },
+    {
+      "name": "join_pre",
+      "description": "join an array of values with separator as a string and using the separator at the beginning of string",
+      "result": null,
+      "category": "array",
+      "category_description": "Array handling routines, eg. join, join_prefix, join_post",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "values",
+          "description": "array of values to join",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        },
+        {
+          "name": "separator",
+          "description": "separator between values, defaults to comma",
+          "splat": null,
+          "default": "','",
+          "param_type": "String"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          return '' if values.nil? || !values.is_a?(::Array)\n          values = values.reject(&:blank?)\n          return '' if values.length.zero?\n\n          \"#{separator}#{values.join(separator)}\"\n"
+    },
+    {
+      "name": "join_post",
+      "description": "join an array of values with separator as a string and using the separator at the end of string",
+      "result": null,
+      "category": "array",
+      "category_description": "Array handling routines, eg. join, join_prefix, join_post",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "values",
+          "description": "array of values to join",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        },
+        {
+          "name": "separator",
+          "description": "separator between values, defaults to comma",
+          "splat": null,
+          "default": "','",
+          "param_type": "String"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "            return '' if values.nil? || !values.is_a?(::Array)\n            values = values.reject(&:blank?)\n            return '' if values.length.zero?\n\n            \"#{values.join(separator)}#{separator}\"\n"
+    }
+  ]
+}

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"
+    }
+  ]
+}