cmdlet 0.1.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4aaf22abcff261a22b71b4c4adeaf77dd8d629836936eabb1b20b2d8a61b3a28
-  data.tar.gz: 4d249fee0dd48b4774881e16bcc92b303f788e45b22c54c14a321a70468bcabf
+  metadata.gz: 49c3beb9fd9aff2b68b44e39e8fcda09b7d54c28413f5295d9bb797c674cf357
+  data.tar.gz: 0c3ecef6805fa262aa2869a5375791ba1ff6db080748519977d5c24509d5159d
 SHA512:
-  metadata.gz: ab39c705f59887093ecbf3a8ad2ec66f133bf14048f544b142b3de324fdb25006dfa19bb66efdf5e281d0167bac8b4bd2958769cff3ad8879515f833f24fa5d5
-  data.tar.gz: e78c0098b63350dfcc77bb7c6c50d902b8da963a9fc8531639a5c6835df4fdae3158b8518f2efd2f87a2fda9dfd9fb3a573f774159c04fad451dca50da09ac43
+  metadata.gz: 7785377593e33ed05090b16277252be0ca0f8893fdcda9a70b6a996b2c77d5e8f2dac2b36f952632a11293630f6db697cad854b8edea2104870edcea7af8646c
+  data.tar.gz: 6f9183a77a87c437dd6dbcdac568075fb05b184be5f6970ff7205df4b209a1201272870224a3b458f2017c93f175d987f429150fa98acc223c2a8dbfd19f7600

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 @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,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/data/cmdlets/inflection.json

@@ -0,0 +1,129 @@
+{
+  "category_key": "inflection",
+  "cmdlets": [
+    {
+      "name": "ordinal",
+      "description": "The suffix that should be added to a number to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th",
+      "result": "ordinal suffix that would be required for a number",
+      "category": "inflection",
+      "category_description": "Inflection handling routines, eg. pluralize, singular, ordinalize",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - numeric value",
+          "splat": null,
+          "default": null,
+          "param_type": "String|Int"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          return '' if value.nil?\n\n          value = value.to_i if value.is_a? String\n\n          value.ordinal\n"
+    },
+    {
+      "name": "ordinalize",
+      "description": "Turns a number into an ordinal string used to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.",
+      "result": "number value turned to 1st, 2nd, 3rd, 4th etc.",
+      "category": "inflection",
+      "category_description": "Inflection handling routines, eg. pluralize, singular, ordinalize",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - numeric value",
+          "splat": null,
+          "default": null,
+          "param_type": "Int"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          return '' if value.nil?\n\n          value = value.to_i if value.is_a? String\n\n          value.ordinalize\n"
+    },
+    {
+      "name": "pluralize",
+      "description": "Returns the plural form of the word in the string",
+      "result": "value in plural form",
+      "category": "inflection",
+      "category_description": "Inflection handling routines, eg. pluralize, singular, ordinalize",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - value to pluralize",
+          "splat": null,
+          "default": null,
+          "param_type": "String"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          return '' if value.nil?\n\n          value = value.to_s if value.is_a?(Symbol)\n\n          value.pluralize\n"
+    },
+    {
+      "name": "pluralize_by_number",
+      "description": "Returns the plural form of the word based on a count",
+      "result": "value and number are used to calculate plural/singular form",
+      "category": "inflection",
+      "category_description": "Inflection handling routines, eg. pluralize, singular, ordinalize",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - value to pluralize",
+          "splat": null,
+          "default": null,
+          "param_type": "String"
+        },
+        {
+          "name": "count",
+          "description": "count used to determine pluralization",
+          "splat": null,
+          "default": null,
+          "param_type": "Int"
+        },
+        {
+          "name": "format",
+          "description": "(Optional) what format should output be. :word, :number_word",
+          "splat": null,
+          "default": null,
+          "param_type": "String"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          return '' if value.nil?\n\n          count = count.to_i if count.is_a? String\n          format = :word if format.nil?\n\n          case format.to_sym\n          when :number_word, :number_and_word\n            \"#{count} #{value.pluralize(count)}\"\n          else # aka :word\n            value.pluralize(count)\n          end\n"
+    },
+    {
+      "name": "singularize",
+      "description": "The reverse of #pluralize, returns the singular form of a word in a string",
+      "result": "plural value turned to singular value",
+      "category": "inflection",
+      "category_description": "Inflection handling routines, eg. pluralize, singular, ordinalize",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "value",
+          "description": "value - value to singularized",
+          "splat": null,
+          "default": null,
+          "param_type": "String"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          return '' if value.nil?\n\n          value = value.to_s if value.is_a?(Symbol)\n\n          value.singularize\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

data/.builders/generators/cmdlets/array.rb

@@ -69,41 +69,3 @@ KManager.action :array_commands do
       .debug
   end
 end
-
-# result                "return block when every value is truthy"
-
-# parameter('values', 'list of values (via *splat) to be checked via AND condition', splat: true)
-
-# example <<-TEXT
-#   {{#if (and p1 p2 p3 p4 p5)}}
-#     found
-#   {{/if}}
-# TEXT
-
-# example <<-TEXT
-#   {{#if (and name age)}}
-#     {{name}}-{{age}}
-#   {{else}}
-#     no name or age
-#   {{/if}}
-# TEXT
-
-# 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