cmdlet 0.0.7 → 0.2.1

data/.builders/data/cmdlets/comparison.json

@@ -0,0 +1,245 @@
+{
+  "category_key": "comparison",
+  "cmdlets": [
+    {
+      "name": "and",
+      "description": "Return true if **all of** the given values are truthy.",
+      "result": "return true when every value is truthy",
+      "category": "comparison",
+      "category_description": "Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "values",
+          "description": "list of values (via *splat) to be checked via AND condition",
+          "splat": "*",
+          "default": null,
+          "param_type": "Object"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          values.all? { |value| value }\n"
+    },
+    {
+      "name": "default",
+      "description": "Return true if **all of** the given values are truthy.",
+      "result": "return true when every value is truthy",
+      "category": "comparison",
+      "category_description": "Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "values",
+          "description": "one or more paramaters that may or may not contain nil",
+          "splat": "*",
+          "default": null,
+          "param_type": "Object"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          default_value = values[-1]\n\n          find_value = values[0..-2].find { |value| !value.nil? }\n\n          find_value || default_value\n"
+    },
+    {
+      "name": "eq",
+      "description": "Return true if two values are equal",
+      "result": "return truthy value if left hand side equals right hand side",
+      "category": "comparison",
+      "category_description": "Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "lhs",
+          "description": "lhs - left hand side value",
+          "splat": null,
+          "default": null,
+          "param_type": "Object"
+        },
+        {
+          "name": "rhs",
+          "description": "rhs - right hand side value",
+          "splat": null,
+          "default": null,
+          "param_type": "Object"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          lhs = lhs.to_s if lhs.is_a?(Symbol)\n          rhs = rhs.to_s if rhs.is_a?(Symbol)\n\n          lhs == rhs\n"
+    },
+    {
+      "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",
+      "category": "comparison",
+      "category_description": "Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "lhs",
+          "description": "lhs - left hand side value",
+          "splat": null,
+          "default": null,
+          "param_type": "Object"
+        },
+        {
+          "name": "rhs",
+          "description": "rhs - right hand side value",
+          "splat": null,
+          "default": null,
+          "param_type": "Object"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          lhs > rhs\n"
+    },
+    {
+      "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",
+      "category": "comparison",
+      "category_description": "Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "lhs",
+          "description": "lhs - left hand side value",
+          "splat": null,
+          "default": null,
+          "param_type": "Object"
+        },
+        {
+          "name": "rhs",
+          "description": "rhs - right hand side value",
+          "splat": null,
+          "default": null,
+          "param_type": "Object"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          lhs >= rhs\n"
+    },
+    {
+      "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",
+      "category": "comparison",
+      "category_description": "Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "lhs",
+          "description": "lhs - left hand side value",
+          "splat": null,
+          "default": null,
+          "param_type": "Object"
+        },
+        {
+          "name": "rhs",
+          "description": "rhs - right hand side value",
+          "splat": null,
+          "default": null,
+          "param_type": "Object"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          lhs < rhs\n"
+    },
+    {
+      "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",
+      "category": "comparison",
+      "category_description": "Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "lhs",
+          "description": "lhs - left hand side value",
+          "splat": null,
+          "default": null,
+          "param_type": "Object"
+        },
+        {
+          "name": "rhs",
+          "description": "rhs - right hand side value",
+          "splat": null,
+          "default": null,
+          "param_type": "Object"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          lhs <= rhs\n"
+    },
+    {
+      "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",
+      "category": "comparison",
+      "category_description": "Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "lhs",
+          "description": "lhs - left hand side value",
+          "splat": null,
+          "default": null,
+          "param_type": "Object"
+        },
+        {
+          "name": "rhs",
+          "description": "rhs - right hand side value",
+          "splat": null,
+          "default": null,
+          "param_type": "Object"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          lhs = lhs.to_s if lhs.is_a?(Symbol)\n          rhs = rhs.to_s if rhs.is_a?(Symbol)\n\n          lhs != rhs\n"
+    },
+    {
+      "name": "or",
+      "description": "Return true if any value is truthy.",
+      "result": "return true when first value is truthy",
+      "category": "comparison",
+      "category_description": "Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.",
+      "base_class_require": null,
+      "base_class": null,
+      "parameters": [
+        {
+          "name": "values",
+          "description": "list of values (via *splat) to be checked via AND condition",
+          "splat": "*",
+          "default": null,
+          "param_type": "Object"
+        }
+      ],
+      "examples": [
+
+      ],
+      "ruby": "          values.any? { |value| value }\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_builder.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class CategoryBuilder < KDirector::Builders::ActionsBuilder
+  def category(name, description)
+    value = {
+      name: name,
+      description: description
+    }
+
+    add(:categories, value: value)
+
+    self
+  end
+
+  def save_categories(**opts)
+    k_builder
+      .cd(:builder_data)
+      .add('categories.json', content: to_json, **opts)
+
+    self
+  end
+
+  def osave_categories(**opts)
+    save_categories(**{ open: true }.merge(opts))
+  end
+end

data/.builders/director/category_dao.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class CategoryDao
+  attr_reader :k_builder
+  attr_reader :load_time
+  attr_reader :data
+
+  def initialize(k_builder)
+    @k_builder = k_builder
+    @load_time = nil
+    @data = nil
+  end
+
+  def file_name
+    k_builder.target_folders.join(:builder_data, 'categories.json')
+  end
+
+  def reload?
+    @load_time.nil? || @load_time < File.mtime(file_name)
+  end
+
+  def find_category(name)
+    result = categories.find { |category| category[:name] == name.to_s }
+
+    raise "Category #{name} not found" if result.nil?
+
+    result
+  end
+
+  def categories
+    if reload?
+      @data = JSON.parse(File.read(file_name), symbolize_names: true)
+      @categories = data[:categories]
+      @load_time = File.mtime(file_name)
+    end
+    @categories
+  end
+end

data/.builders/director/category_director.rb

@@ -1,25 +1,39 @@
 # frozen_string_literal: true
 
 class CategoryDirector < KDirector::Directors::BaseDirector
-  def category(name, description)
-    value = {
-      name: name,
-      description: description
-    }
+  defaults(builder_type: CategoryBuilder, on_exist: :write, on_action: :execute)
 
-    builder.add(:categories, value: value)
+  def category(name, description)
+    builder.category(name, description)
 
     self
   end
 
-  def category_file
-    k_builder.target_folders.join(:builder_data, 'categories.json')
+  def generate
+    generate_require_all_cmdlets
+
+    self
   end
 
-  def save_categories
+  def save_categories(**opts)
     cd(:builder_data)
-    add('categories.json', content: builder.to_json)
+    add('categories.json', content: builder.to_json, **opts)
 
     self
   end
+
+  def osave_categories(**opts)
+    save_categories(**{ open: true }.merge(opts))
+  end
+
+  private
+
+  def generate_require_all_cmdlets
+    cd(:lib)
+    add('_.rb',
+      template_file: 'require_all_cmdlets.rb',
+      cmdlets: data_access.cmdlet.all_cmdlets)
+
+  end
+  
 end

data/.builders/director/cmdlet_builder.rb

@@ -1,72 +1,65 @@
 # frozen_string_literal: true
 
 class CmdletBuilder < KDirector::Builders::ActionsBuilder
-  attr_reader :current_helper
-  # attr_accessor :actions
-  # attr_accessor :last_action
+  attr_reader :current_cmdlet
 
   def initialize
     super
 
-    dom[:helpers] = []
-    dom[:categories] = []
-    # @actions = []
-    # @last_action = {}
+    dom[:category_key] = nil
+    dom[:cmdlets] = []
   end
 
-  def category(name, description)
-    dom[:categories] << {
-      name: name,
-      description: description,
-    }
+  def category_key
+    dom[:category_key]
+  end
+
+  def category_key=(value)
+    set(:category_key, value: value)
   end
 
-  def helpers
-    dom[:helpers]
+  def cmdlets
+    dom[:cmdlets]
   end
 
-  def add_helper
-    @current_helper = new_helper
-    dom[:helpers] << current_helper
+  def add_cmdlet
+    @current_cmdlet = new_cmdlet
+    dom[:cmdlets] << current_cmdlet
   end
 
-  def helper_setting(name, value)
-    @current_helper[name] = value
+  def cmdlet_setting(name, value)
+    @current_cmdlet[name] = value
   end
 
-  def add_helper_parameter(name, description, splat: false)
+  def add_cmdlet_parameter(name, description, **opts)
     parameter = {
       name: name,
-      description: description,
-      splat: splat
-    }
+      description: description
+    }.merge(opts)
 
-    @current_helper[:parameters] << parameter
+    @current_cmdlet[:parameters] << parameter
   end
 
-  def add_helper_example(value)
+  def add_cmdlet_example(value)
     lines = value.split("\n")
     value = lines.map { |line| "        # #{line.strip}" }.join("\n")
 
-    @current_helper[:examples] << value
+    @current_cmdlet[:examples] << value
   end
 
-
   private
 
-  def new_helper
+  def new_cmdlet
+    category = data_access.category.find_category(category_key)
+
     {
       name: nil,
       description: nil,
       result: nil,
-      category: nil,
-      category_description: nil,
+      category: category[:name],
+      category_description: category[:description],
       base_class_require: nil,
       base_class: nil,
-      example_input_value: nil,
-      example_output_value: nil,
-      test_input_value: nil,
-      test_output_value: nil,
       parameters: [],
       examples: []
     }

data/.builders/director/cmdlet_child.rb

@@ -1,67 +1,39 @@
 # frozen_string_literal: true
 
-class HandlebarsHelperChild < KDirector::Directors::ChildDirector
+class CmdletChild < KDirector::Directors::ChildDirector
   def initialize(parent, **opts)
     super(parent, **opts)
 
-    builder.add_helper
-
-    # defaults = {
-    #   repo_name: opts[:repo_name], # || parent.builder.dom&[:github]&[:repo_name]
-    #   username: opts[:username] || default_github_username, # || parent.builder.dom&[:github]&[:username]
-    #   organization: opts[:organization] # || parent.builder.dom&[:github]&[:organization]
-    # }
+    builder.add_cmdlet
   end
 
   def name(value)
-    builder.helper_setting(:name, value)
+    builder.cmdlet_setting(:name, value)
   end
 
   def description(value)
-    builder.helper_setting(:description, value)
+    builder.cmdlet_setting(:description, value)
   end
 
   def result(value)
-    builder.helper_setting(:result, value)
-  end
-
-  def category(value)
-    builder.helper_setting(:category, value)
+    builder.cmdlet_setting(:result, value)
   end
 
-  def category_description(value)
-    builder.helper_setting(:category_description, value)
+  def ruby(value)
+    builder.cmdlet_setting(:ruby, value)
   end
 
-  # def base_class_require(value)
-  #   builder.helper_setting(:base_class_require, value)
-  # end
-
-  # def base_class(value)
-  #   builder.helper_setting(:base_class, value)
-  # end
-
-  # def example_input_value(value)
-  #   builder.helper_setting(:example_input_value, value)
-  # end
-
-  # def example_output_value(value)
-  #   builder.helper_setting(:example_output_value, value)
-  # end
-
-  # def test_input_value(value)
-  #   builder.helper_setting(:test_input_value, value)
-  # end
-
-  # def test_output_value(value)
-  #   builder.helper_setting(:test_output_value, value)
-  # end
-
-  def parameter(name, description, splat: false)
-    builder.add_helper_parameter(name, description, splat: splat)
+  def parameter(name, description, splat: nil, default: nil, param_type: 'String')
+    builder.add_cmdlet_parameter(
+      name,
+      description,
+      splat: splat,
+      default: default,
+      param_type: param_type
+    )
   end
 
   def example(value)
-    builder.add_helper_example(value)
+    builder.add_cmdlet_example(value)
   end
 end