cmdlet 0.0.7 → 0.2.1

data/lib/cmdlet/array/join_pre.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Array handling routines, eg. join, join_prefix, join_post
+  module Array
+    # JoinPre: join an array of values with separator as a string and using the separator at the beginning of string
+    class JoinPre < 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?
+
+        "#{separator}#{values.join(separator)}"
+      end
+    end
+  end
+end

data/lib/cmdlet/base_cmdlet.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # base cmdlet provides an interface for cmdlets
+  class BaseCmdlet
+    def call(value)
+      value
+    end
+
+    # String tokenizer will clean up a string so that
+    # all sorts of case formatted strings can be
+    # represented in a consistent fashion
+    def 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/comparison/and.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.
+  module Comparison
+    # And: Return true if **all of** the given values are truthy.
+    class And < Cmdlet::BaseCmdlet
+      #
+      # @param [Object] values - list of values (via *splat) to be checked via AND condition
+      # @return [String] return true when every value is truthy
+      def call(*values)
+        values.all? { |value| value }
+      end
+    end
+  end
+end

data/lib/cmdlet/comparison/default.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.
+  module Comparison
+    # Default: Return true if **all of** the given values are truthy.
+    class Default < Cmdlet::BaseCmdlet
+      #
+      # @param [Object] values - one or more paramaters that may or may not contain nil
+      # @return [String] return true when every value is truthy
+      def call(*values)
+        default_value = values[-1]
+
+        find_value = values[0..-2].find { |value| !value.nil? }
+
+        find_value || default_value
+      end
+    end
+  end
+end

data/lib/cmdlet/comparison/eq.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.
+  module Comparison
+    # Eq: Return true if two values are equal
+    class Eq < Cmdlet::BaseCmdlet
+      #
+      # @param [Object] lhs - lhs - left hand side value
+      # @param [Object] rhs - rhs - right hand side value
+      # @return [String] return truthy value if left hand side equals right hand side
+      def call(lhs, rhs)
+        lhs = lhs.to_s if lhs.is_a?(Symbol)
+        rhs = rhs.to_s if rhs.is_a?(Symbol)
+
+        lhs == rhs
+      end
+    end
+  end
+end

data/lib/cmdlet/comparison/gt.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.
+  module Comparison
+    # Gt: Return true if left hand side GREATER THAN right hand side
+    class Gt < Cmdlet::BaseCmdlet
+      #
+      # @param [Object] lhs - lhs - left hand side value
+      # @param [Object] rhs - rhs - right hand side value
+      # @return [String] truthy value if left hand side GREATER THAN right hand side
+      def call(lhs, rhs)
+        lhs > rhs
+      end
+    end
+  end
+end

data/lib/cmdlet/comparison/gte.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.
+  module Comparison
+    # Gte: Return true if left hand side GREATER THAN or EQUAL TO right hand side
+    class Gte < Cmdlet::BaseCmdlet
+      #
+      # @param [Object] lhs - lhs - left hand side value
+      # @param [Object] rhs - rhs - right hand side value
+      # @return [String] truthy value if left hand side GREATER THAN or EQUAL TO  right hand side
+      def call(lhs, rhs)
+        lhs >= rhs
+      end
+    end
+  end
+end

data/lib/cmdlet/comparison/lt.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.
+  module Comparison
+    # Lt: Return true if left hand side LESS THAN right hand side
+    class Lt < Cmdlet::BaseCmdlet
+      #
+      # @param [Object] lhs - lhs - left hand side value
+      # @param [Object] rhs - rhs - right hand side value
+      # @return [String] truthy value if left hand side LESS THAN right hand side
+      def call(lhs, rhs)
+        lhs < rhs
+      end
+    end
+  end
+end

data/lib/cmdlet/comparison/lte.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.
+  module Comparison
+    # Lte: Return true if left hand side LESS THAN or EQUAL TO right hand side
+    class Lte < Cmdlet::BaseCmdlet
+      #
+      # @param [Object] lhs - lhs - left hand side value
+      # @param [Object] rhs - rhs - right hand side value
+      # @return [String] truthy value if left hand side LESS THAN or EQUAL TO  right hand side
+      def call(lhs, rhs)
+        lhs <= rhs
+      end
+    end
+  end
+end

data/lib/cmdlet/comparison/ne.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.
+  module Comparison
+    # Ne: Return true if left hand side is NOT equal to right hand side
+    class Ne < Cmdlet::BaseCmdlet
+      #
+      # @param [Object] lhs - lhs - left hand side value
+      # @param [Object] rhs - rhs - right hand side value
+      # @return [String] truthy value if left hand side is NOT equal to right hand side
+      def call(lhs, rhs)
+        lhs = lhs.to_s if lhs.is_a?(Symbol)
+        rhs = rhs.to_s if rhs.is_a?(Symbol)
+
+        lhs != rhs
+      end
+    end
+  end
+end

data/lib/cmdlet/comparison/or.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.
+  module Comparison
+    # Or: Return true if any value is truthy.
+    class Or < Cmdlet::BaseCmdlet
+      #
+      # @param [Object] values - list of values (via *splat) to be checked via AND condition
+      # @return [String] return true when first value is truthy
+      def call(*values)
+        values.any? { |value| value }
+      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

data/lib/cmdlet/inflection/ordinalize.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Inflection handling routines, eg. pluralize, singular, ordinalize
+  module Inflection
+    # Ordinalize: Turns a number into an ordinal string used to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+    class Ordinalize < Cmdlet::BaseCmdlet
+      #
+      # @param [Int] value - value - numeric value
+      # @return [String] number value turned to 1st, 2nd, 3rd, 4th etc.
+      def call(value)
+        return '' if value.nil?
+
+        value = value.to_i if value.is_a? String
+
+        value.ordinalize
+      end
+    end
+  end
+end

data/lib/cmdlet/inflection/pluralize.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Inflection handling routines, eg. pluralize, singular, ordinalize
+  module Inflection
+    # Pluralize: Returns the plural form of the word in the string
+    class Pluralize < Cmdlet::BaseCmdlet
+      #
+      # @param [String] value - value - value to pluralize
+      # @return [String] value in plural form
+      def call(value)
+        return '' if value.nil?
+
+        value = value.to_s if value.is_a?(Symbol)
+
+        value.pluralize
+      end
+    end
+  end
+end

data/lib/cmdlet/inflection/pluralize_by_number.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Inflection handling routines, eg. pluralize, singular, ordinalize
+  module Inflection
+    # PluralizeByNumber: Returns the plural form of the word based on a count
+    class PluralizeByNumber < Cmdlet::BaseCmdlet
+      #
+      # @param [String] value - value - value to pluralize
+      # @param [Int] count - count used to determine pluralization
+      # @param [String] format - (Optional) what format should output be. :word, :number_word
+      # @return [String] value and number are used to calculate plural/singular form
+      def call(value, count, format)
+        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
+      end
+    end
+  end
+end

data/lib/cmdlet/inflection/singularize.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Cmdlet
+  # Inflection handling routines, eg. pluralize, singular, ordinalize
+  module Inflection
+    # Singularize: The reverse of #pluralize, returns the singular form of a word in a string
+    class Singularize < Cmdlet::BaseCmdlet
+      #
+      # @param [String] value - value - value to singularized
+      # @return [String] plural value turned to singular value
+      def call(value)
+        return '' if value.nil?
+
+        value = value.to_s if value.is_a?(Symbol)
+
+        value.singularize
+      end
+    end
+  end
+end

data/lib/cmdlet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cmdlet
-  VERSION = '0.0.7'
+  VERSION = '0.2.1'
 end

data/lib/cmdlet.rb

@@ -2,10 +2,15 @@
 
 # require 'k_log'
 require 'k_config'
+require 'active_support/core_ext/integer/inflections'
+
 require_relative 'cmdlet/version'
 require_relative 'cmdlet/configuration'
+require_relative 'cmdlet/base_cmdlet'
 require_relative 'cmdlet/string_tokenizer'
 
+require_relative 'cmdlet/_'
+
 module Cmdlet
   # raise Cmdlet::Error, 'Sample message'
   Error = Class.new(StandardError)

data/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "cmdlet",
-  "version": "0.0.7",
+  "version": "0.2.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "cmdlet",
-      "version": "0.0.7",
+      "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.0.7",
+  "version": "0.2.1",
   "description": "Cmdlet provides a set of functions (wrapped in the command pattern) that perform simple actions",
   "scripts": {
     "release": "semantic-release"