cmdlet 0.0.7 → 0.2.1

data/.builders/generators/30-commands-bak.rb

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

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+KManager.action :array_commands do
+  action do
+    CmdletDirector
+      .init(k_builder, category: :array)
+      .cmdlet do
+        name :join
+        description           'join an array of values with separator as a string'
+        result                'new String formed by joining the array elements with seperator'
+
+        parameter             :values, 'array of values to join', param_type: 'String|Int'
+        parameter             :separator, 'separator between values, defaults to comma', default: "','"
+
+        ruby <<-RUBY
+          return false if values.nil? || values.length == 0
+          values = values.reject(&:blank?)
+          return '' if values.length.zero?
+
+          values.join(separator)
+        RUBY
+      end
+      .cmdlet do
+        name :join_pre
+        description           'join an array of values with separator as a string and using the separator at the beginning of string'
+
+        parameter             :values, 'array of values to join', param_type: 'String|Int'
+        parameter             :separator, 'separator between values, defaults to comma', default: "','"
+
+        ruby <<-'RUBY'
+          return '' if values.nil? || !values.is_a?(::Array)
+          values = values.reject(&:blank?)
+          return '' if values.length.zero?
+
+          "#{separator}#{values.join(separator)}"
+        RUBY
+      end
+      .cmdlet do
+        name :join_pre
+        description           'join an array of values with separator as a string and using the separator at the beginning of string'
+
+        parameter             :values, 'array of values to join', param_type: 'String|Int'
+        parameter             :separator, 'separator between values, defaults to comma', default: "','"
+
+        ruby <<-'RUBY'
+          return '' if values.nil? || !values.is_a?(::Array)
+          values = values.reject(&:blank?)
+          return '' if values.length.zero?
+
+          "#{separator}#{values.join(separator)}"
+        RUBY
+      end
+      .cmdlet do
+        name :join_post
+        description           'join an array of values with separator as a string and using the separator at the end of string'
+
+        parameter             :values, 'array of values to join', param_type: 'String|Int'
+        parameter             :separator, 'separator between values, defaults to comma', default: "','"
+
+        ruby <<-'RUBY'
+            return '' if values.nil? || !values.is_a?(::Array)
+            values = values.reject(&:blank?)
+            return '' if values.length.zero?
+
+            "#{values.join(separator)}#{separator}"
+        RUBY
+      end
+      .generate
+      .debug
+  end
+end

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/.builders/generators/cmdlets/comparison.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+KManager.action :comparison_commands do
+  action do
+    CmdletDirector
+      .init(k_builder, category: :comparison)
+      .cmdlet do
+        name :and
+        description           'Return true if **all of** the given values are truthy.'
+        result                'return true when every value is truthy'
+
+        parameter             :values, 'list of values (via *splat) to be checked via AND condition', splat: '*', param_type: 'Object'
+
+        ruby <<-RUBY
+          values.all? { |value| value }
+        RUBY
+      end
+      .cmdlet do
+        name :default
+        description           'Return true if **all of** the given values are truthy.'
+        result                'return true when every value is truthy'
+
+        parameter             :values, 'one or more paramaters that may or may not contain nil', splat: '*', param_type: 'Object'
+
+        ruby <<-RUBY
+          default_value = values[-1]
+
+          find_value = values[0..-2].find { |value| !value.nil? }
+
+          find_value || default_value
+        RUBY
+
+      end
+      .cmdlet do
+        name :eq
+        description           'Return true if two values are equal'
+        result                'return truthy value if left hand side equals right hand side'
+
+        parameter             :lhs, 'lhs - left hand side value', param_type: 'Object'
+        parameter             :rhs, 'rhs - right hand side value', param_type: 'Object'
+
+        ruby <<-RUBY
+          lhs = lhs.to_s if lhs.is_a?(Symbol)
+          rhs = rhs.to_s if rhs.is_a?(Symbol)
+
+          lhs == rhs
+        RUBY
+      end
+      .cmdlet do
+        name :gt
+        description           'Return true if left hand side GREATER THAN right hand side'
+        result                'truthy value if left hand side GREATER THAN right hand side'
+
+        parameter             :lhs, 'lhs - left hand side value', param_type: 'Object'
+        parameter             :rhs, 'rhs - right hand side value', param_type: 'Object'
+
+        ruby <<-RUBY
+          lhs > rhs
+        RUBY
+      end
+      .cmdlet do
+        name :gte
+        description           'Return true if left hand side GREATER THAN or EQUAL TO right hand side'
+        result                'truthy value if left hand side GREATER THAN or EQUAL TO  right hand side'
+
+        parameter             :lhs, 'lhs - left hand side value', param_type: 'Object'
+        parameter             :rhs, 'rhs - right hand side value', param_type: 'Object'
+
+        ruby <<-RUBY
+          lhs >= rhs
+        RUBY
+      end
+      .cmdlet do
+        name :lt
+        description           'Return true if left hand side LESS THAN right hand side'
+        result                'truthy value if left hand side LESS THAN right hand side'
+
+        parameter             :lhs, 'lhs - left hand side value', param_type: 'Object'
+        parameter             :rhs, 'rhs - right hand side value', param_type: 'Object'
+
+        ruby <<-RUBY
+          lhs < rhs
+        RUBY
+      end
+      .cmdlet do
+        name :lte
+        description           'Return true if left hand side LESS THAN or EQUAL TO right hand side'
+        result                'truthy value if left hand side LESS THAN or EQUAL TO  right hand side'
+
+        parameter             :lhs, 'lhs - left hand side value', param_type: 'Object'
+        parameter             :rhs, 'rhs - right hand side value', param_type: 'Object'
+
+        ruby <<-RUBY
+          lhs <= rhs
+        RUBY
+      end
+      .cmdlet do
+        name :ne
+        description           'Return true if left hand side is NOT equal to right hand side'
+        result                'truthy value if left hand side is NOT equal to right hand side'
+
+        parameter             :lhs, 'lhs - left hand side value', param_type: 'Object'
+        parameter             :rhs, 'rhs - right hand side value', param_type: 'Object'
+
+        ruby <<-RUBY
+          lhs = lhs.to_s if lhs.is_a?(Symbol)
+          rhs = rhs.to_s if rhs.is_a?(Symbol)
+
+          lhs != rhs
+        RUBY
+      end
+      .cmdlet do
+        name :or
+        description           'Return true if any value is truthy.'
+        result                'return true when first value is truthy'
+
+        parameter             :values, 'list of values (via *splat) to be checked via AND condition', splat: '*', param_type: 'Object'
+
+        ruby <<-RUBY
+          values.any? { |value| value }
+        RUBY
+      end
+    .generate
+    .debug
+  end
+end

data/.builders/generators/cmdlets/inflection.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+KManager.action :inflection_commands do
+  action do
+    CmdletDirector
+      .init(k_builder, category: :inflection)
+      .cmdlet do
+        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'
+
+        parameter             :value, 'value - numeric value', param_type: 'String|Int'
+
+        ruby <<-RUBY
+          return '' if value.nil?
+
+          value = value.to_i if value.is_a? String
+
+          value.ordinal
+        RUBY
+      end
+      .cmdlet do
+        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.'
+
+        parameter             :value, 'value - numeric value', param_type: 'Int'
+
+        ruby <<-RUBY
+          return '' if value.nil?
+
+          value = value.to_i if value.is_a? String
+
+          value.ordinalize
+        RUBY
+      end
+      .cmdlet do
+        name :pluralize
+        description           'Returns the plural form of the word in the string'
+        result                'value in plural form'
+
+        parameter             :value, 'value - value to pluralize', param_type: 'String'
+
+        ruby <<-RUBY
+          return '' if value.nil?
+
+          value = value.to_s if value.is_a?(Symbol)
+
+          value.pluralize
+        RUBY
+      end
+      .cmdlet do
+        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'
+
+        parameter             :value, 'value - value to pluralize', param_type: 'String'
+        parameter             :count, 'count used to determine pluralization', param_type: 'Int'
+        parameter             :format, '(Optional) what format should output be. :word, :number_word'
+
+        ruby <<-'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
+      end
+      .cmdlet do
+        name :singularize
+        description           'The reverse of #pluralize, returns the singular form of a word in a string'
+        result                'plural value turned to singular value'
+
+        parameter             :value, 'value - value to singularized', param_type: 'String'
+
+        ruby <<-RUBY
+          return '' if value.nil?
+
+          value = value.to_s if value.is_a?(Symbol)
+
+          value.singularize
+        RUBY
+      end
+      .generate
+      .debug
+  end
+end

data/CHANGELOG.md

@@ -1,3 +1,40 @@
+# [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)
+
+
+### Bug Fixes
+
+* add comparison :or ([633633d](https://github.com/klueless-io/cmdlet/commit/633633d2a22b98a0de1acf6257feb3603a2f2c39))
+* add comparison :or, :and, :lt, :lte, :gt, :gte, :ne, :eq, :default ([000cb1a](https://github.com/klueless-io/cmdlet/commit/000cb1a3cbd643abcb5dac6828972ec94c9f53a8))
+
+## [0.1.1](https://github.com/klueless-io/cmdlet/compare/v0.1.0...v0.1.1) (2022-07-10)
+
+
+### Bug Fixes
+
+* add specs ([80f384f](https://github.com/klueless-io/cmdlet/commit/80f384f9f7cd1c1ea67396bb12d3119c433ea139))
+
+# [0.1.0](https://github.com/klueless-io/cmdlet/compare/v0.0.7...v0.1.0) (2022-07-09)
+
+
+### Features
+
+* generate commandlets ([a61948e](https://github.com/klueless-io/cmdlet/commit/a61948e285d488d3aab68a9ef3bd0c136b87170f))
+
+## [0.0.7](https://github.com/klueless-io/cmdlet/compare/v0.0.6...v0.0.7) (2022-07-09)
+
+
+### Bug Fixes
+
+* add category director ([3b72b72](https://github.com/klueless-io/cmdlet/commit/3b72b72d9f739c9a3711f14a640bb6d527e17140))
+* add category director ([cea0f1a](https://github.com/klueless-io/cmdlet/commit/cea0f1ae37bfbb67d634f18cf1d315a80c1f6082))
+
 ## [0.0.6](https://github.com/klueless-io/cmdlet/compare/v0.0.5...v0.0.6) (2022-07-08)
 
 

data/Guardfile

@@ -19,7 +19,7 @@ group :green_pass_then_cop, halt_on_fail: true do
     # Ruby files
     ruby = dsl.ruby
     dsl.watch_spec_files_for(ruby.lib_files)
-    watch(%r{^lib//(.+)\.rb$}) { |m| "spec/unit/#{m[1]}_spec.rb" }
+    watch(%r{^lib//(.+)\.rb$}) { |m| "spec/**/#{m[1]}_spec.rb" }
     watch(%r{^lib//commands/(.+)\.rb$}) { |m| "spec/unit/commands/#{m[1]}_spec.rb" }
   end
 

data/lib/cmdlet/_.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+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'
+require_relative 'comparison/gt'
+require_relative 'comparison/gte'
+require_relative 'comparison/lt'
+require_relative 'comparison/lte'
+require_relative 'comparison/ne'
+require_relative 'comparison/or'
+require_relative 'inflection/ordinal'
+require_relative 'inflection/ordinalize'
+require_relative 'inflection/pluralize'
+require_relative 'inflection/pluralize_by_number'
+require_relative 'inflection/singularize'

data/lib/cmdlet/array/join.rb

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

data/lib/cmdlet/array/join_post.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Array handling routines, eg. join, join_prefix, join_post
+  module Array
+    # JoinPost: join an array of values with separator as a string and using the separator at the end of string
+    class JoinPost < Cmdlet::BaseCmdlet
+      #
+      # @param [String|Int] values - array of values to join
+      # @param [String] separator - separator between values, defaults to comma
+      # @return [String]
+      def call(values, separator = ',')
+        return '' if values.nil? || !values.is_a?(::Array)
+
+        values = values.reject(&:blank?)
+        return '' if values.length.zero?
+
+        "#{values.join(separator)}#{separator}"
+      end
+    end
+  end
+end