cmdlet 0.1.2 → 0.3.0

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

@@ -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
@@ -124,41 +124,3 @@ KManager.action :comparison_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

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,25 @@
+## [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)
+
+
+### 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)
 
 

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'
@@ -12,3 +26,8 @@ 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/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/inflection/ordinal.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Inflection handling routines, eg. pluralize, singular, ordinalize
+  module 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
+    class Ordinal < Cmdlet::BaseCmdlet
+      #
+      # @param [String|Int] value - value - numeric value
+      # @return [String] ordinal suffix that would be required for a number
+      def call(value)
+        return '' if value.nil?
+
+        value = value.to_i if value.is_a? String
+
+        value.ordinal
+      end
+    end
+  end
+end