cmdlet 0.0.5 → 0.1.2

data/.builders/director/cmdlet_builder.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class CmdletBuilder < KDirector::Builders::ActionsBuilder
+  attr_reader :current_cmdlet
+
+  def initialize
+    super
+
+    dom[:category_key] = nil
+    dom[:cmdlets] = []
+  end
+
+  def category_key
+    dom[:category_key]
+  end
+
+  def category_key=(value)
+    set(:category_key, value: value)
+  end
+
+  def cmdlets
+    dom[:cmdlets]
+  end
+
+  def add_cmdlet
+    @current_cmdlet = new_cmdlet
+    dom[:cmdlets] << current_cmdlet
+  end
+
+  def cmdlet_setting(name, value)
+    @current_cmdlet[name] = value
+  end
+
+  def add_cmdlet_parameter(name, description, **opts)
+    parameter = {
+      name: name,
+      description: description
+    }.merge(opts)
+
+    @current_cmdlet[:parameters] << parameter
+  end
+
+  def add_cmdlet_example(value)
+    lines = value.split("\n")
+    value = lines.map { |line| "        # #{line.strip}" }.join("\n")
+
+    @current_cmdlet[:examples] << value
+  end
+
+  private
+
+  def new_cmdlet
+    category = data_access.category.find_category(category_key)
+
+    {
+      name: nil,
+      description: nil,
+      result: nil,
+      category: category[:name],
+      category_description: category[:description],
+      base_class_require: nil,
+      base_class: nil,
+      parameters: [],
+      examples: []
+    }
+  end
+end

data/.builders/director/cmdlet_child.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class CmdletChild < KDirector::Directors::ChildDirector
+  def initialize(parent, **opts)
+    super(parent, **opts)
+
+    builder.add_cmdlet
+  end
+
+  def name(value)
+    builder.cmdlet_setting(:name, value)
+  end
+
+  def description(value)
+    builder.cmdlet_setting(:description, value)
+  end
+
+  def result(value)
+    builder.cmdlet_setting(:result, value)
+  end
+
+  def ruby(value)
+    builder.cmdlet_setting(:ruby, value)
+  end
+
+  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_cmdlet_example(value)
+  end
+end

data/.builders/director/cmdlet_dao.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class CmdletDao
+  attr_reader :k_builder
+
+  def initialize(k_builder)
+    @k_builder = k_builder
+  end
+
+  def all_cmdlets
+    data_access
+      .category
+      .categories.flat_map { |category| read_cmdlets(category[:name]) }
+      .compact
+      .uniq
+      .sort_by { |r| [r[:category], r[:name]] }
+  end
+
+  private
+
+  def read_cmdlets(category_name)
+    file_name = k_builder.target_folders.join(:builder_data, 'cmdlets', "#{category_name}.json")
+
+    return JSON.parse(File.read(file_name), symbolize_names: true)[:cmdlets] if File.exist?(file_name)
+
+    puts "Cmdlet file #{file_name} not found"
+    nil
+  end
+end

data/.builders/director/cmdlet_director.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class CmdletDirector < KDirector::Directors::BaseDirector
+  defaults(builder_type: CmdletBuilder, on_exist: :write, on_action: :execute)
+
+  def initialize(k_builder, builder, **opts)
+    super(k_builder, builder, **opts)
+
+    builder.category_key = opts[:category] || :unknown
+  end
+
+  def cmdlet(**opts, &block)
+    cmdlet = CmdletChild.new(self, **opts)
+    cmdlet.instance_eval(&block) if block_given?
+
+    self
+  end
+
+  def categories
+    data_access.category_director.categories
+  end
+
+  def generate
+    build_cmdlets
+    save_cmdlets
+    run_cop
+
+    self
+  end
+
+  def build_cmdlets
+    builder.cmdlets.each do |cmdlet|
+      cmdlet_file = "#{cmdlet[:category]}/#{cmdlet[:name]}.rb"
+      cmdlet_spec_file = "#{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)
+    end
+
+    self
+  end
+
+  def run_cop
+    Dir.chdir(k_builder.target_folders.get(:app)) do
+      k_builder.run_cop('**/*.rb', fix_unsafe: true)
+    end
+
+    self
+  end
+
+  def save_cmdlets
+    cd(:builder_data)
+    add("cmdlets/#{builder.category_key}.json", content: builder.to_json)
+
+    self
+  end
+end

data/.builders/director/dao.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+def data_access
+  @data_access ||= Dao.new(k_builder)
+end
+
+class Dao
+  attr_reader :k_builder
+  attr_reader :category
+  attr_reader :cmdlet
+
+  def initialize(k_builder)
+    @category = CategoryDao.new(k_builder)
+    @cmdlet = CmdletDao.new(k_builder)
+  end
+end

data/.builders/documents/commands.rb

@@ -1,31 +1,225 @@
+# frozen_string_literal: true
+
 def commands
-  functions.map do |function|
-    category = categories.find { |c| c.name == function.category }
-
-    
-    log.error("Category '#{function.category}' not found") unless category
-  
-    OpenStruct.new(
-      category: function.category,
-      name: function.name,
-      category_description: category.description,
-      function_description: function.description,
-      ruby: function.ruby,
-      usecases: use_cases
-        .select { |uc| uc.category == function.category && uc.function == function.name }
-        .map { |uc| 
-          OpenStruct.new({
-            category:         uc.category,
-            function:         uc.function,
-            inputs:           uc.inputs,
-            nice_inputs:      nice_inputs(uc.inputs),
-            expected_output:  uc.expected_output 
-          })
-        }
-    )
+  return @commands unless @commands.nil?
+
+  result = KDoc.model :document do
+    table :rows do
+      fields :category, :name, :alias, :description, :ruby # , f(name: :params, default: [:value])
+
+      # context 'when array of string' do
+      #   let(:value) { %w[the quick fox] }
+
+      #   it { is_expected.to eq('the,quick,fox') }
+      # end
+
+      # context 'when array of numbers' do
+      #   let(:value) { [1, 2, 3] }
+
+      #   it { is_expected.to eq('1,2,3') }
+      # end
+
+      # context 'when array of symbol' do
+      #   let(:value) { %i[the quick fox] }
+
+      #   it { is_expected.to eq('the,quick,fox') }
+      # end
+
+      row :array                , :join            , []    , 'join an array of values with separator as a string', <<-'RUBY'
+        return '' if value.nil? || !value.is_a?(Array)
+        values = value.reject(&:blank?)
+        return '' if value.length.zero?
+
+        separator = ','
+        values.join(separator)
+      RUBY
+
+      row :array                , :join_pre , [] , 'join an array of values with separator as a string and using the separator at the beginning of string', <<-'RUBY'
+        return '' if value.nil? || !value.is_a?(Array)
+        values = value.reject(&:blank?)
+        return '' if value.length.zero?
+
+        separator = ','
+        "#{separator}#{value.join(separator)}"
+      RUBY
+
+      # row :array                , :join_post       , []    , "join an array of values with separator as a string and using the separator at the end of string", <<-'RUBY'
+      #   return '' if value.nil? || !value.is_a?(Array)
+      #   values = value.reject(&:blank?)
+      #   return '' if value.length.zero?
+
+      #   separator = ','
+      #   "#{value.join(separator)}#{separator}"
+      # RUBY
+
+      # row :a_transform            , :backslash            , [:back_slash]                    , "convert to back slash notation", <<-'RUBY'
+      #   tokenizer.parse(value, preserve_case: true, separator: '\\')
+      # RUBY
+
+      # row :a_transform            , :camel                , [:upper_camel, :pascal]          , "convert to camel notation", <<-'RUBY'
+      #   tokenizer.parse(value).underscore.camelize
+      # RUBY
+
+      # row :a_transform            , :constant             , [:constantize]                   , "", <<-'RUBY'
+      #   tokenizer.parse(value, separator: '_').upcase
+      # RUBY
+
+      # row :a_transform            , :dash                 , [:dasherize]                     , "convert to dash notation", <<-'RUBY'
+      #   tokenizer.parse(value)
+      # RUBY
+
+      # row :a_transform            , :dot                  , [:dotirize]                      , "", <<-'RUBY'
+      #   tokenizer.parse(value, separator: '.')
+      # RUBY
+
+      # row :a_transform            , :double_colon         , []                               , "", <<-'RUBY'
+      #   tokenizer.parse(value, preserve_case: true, separator: '::')
+      # RUBY
+
+      # row :a_transform            , :lower                , [:lowercase, :downcase]          , "", <<-'RUBY'
+      #   return '' if value.nil?
+
+      #   value.downcase
+      # RUBY
+
+      # # row :a_transform            , :format_as            , []                               , "", <<-'RUBY'
+
+      # # RUBY
+
+      # row :a_transform            , :proper            , []                               , "Proper case capitalizes the first letter of ALL words in a string", <<-'RUBY'
+      # tokenizer.parse(value,
+      #         separator: ' ',
+      #         preserve_case: true,
+      #         compress_prefix_numerals: false,
+      #         compress_suffix_numerals: false)
+      #   .titleize
+      # RUBY
+
+      # row :a_transform            , :sentence             , [:human, :humanize]              , "Upper case for first letter only.  Numbers will maintain their spacing", <<-'RUBY'
+      #   tokenizer.parse(value,
+      #                   separator: ' ',
+      #                   preserve_case: true,
+      #                   compress_prefix_numerals: false,
+      #                   compress_suffix_numerals: false)
+      #             .humanize
+      # RUBY
+
+      # row :a_transform            , :lamel                , [:lower_camel]                   , "", <<-'RUBY'
+      #   tokenizer.parse(value, separator: '_').camelize(:lower)
+      # RUBY
+
+      # row :a_transform            , :slash                , [:forwardslash, :forward_slash]  , "", <<-'RUBY'
+      #   tokenizer.parse(value, preserve_case: true, separator: '/')
+      # RUBY
+
+      # row :a_transform            , :snake                , [:snake]                         , "", <<-'RUBY'
+      #   tokenizer.parse(value, separator: '_', forced_separator: true)
+      # RUBY
+
+      # row :a_transform            , :title                , [:titleize]                      , "", <<-'RUBY'
+      #   tokenizer.parse(value,
+      #                   separator: ' ',
+      #                   preserve_case: true,
+      #                   compress_prefix_numerals: false,
+      #                   compress_suffix_numerals: false)
+      #            .titleize
+      # RUBY
+
+      # row :a_transform            , :upper                , [:upper_case, :upcase]           , "", <<-'RUBY'
+      #   return '' if value.nil?
+
+      #   value.upcase
+      # RUBY
+
+      # row :a_comparison         , :and                  , [:all] , "", <<-'RUBY'
+      #   values.all? { |value| value }
+      # RUBY
+
+      # # DEFAULT does not make sense in comparison
+      # row :a_comparison         , :default              , [:fallback] , "", <<-'RUBY'
+      #   default_value = values[-1]
+
+      #   find_value = values[0..-2].find { |value| !value.nil? }
+
+      #   find_value || default_value
+      # RUBY
+
+      # row :a_comparison         , :eq                   , [:equal] , "", <<-'RUBY'
+      #   lhs = lhs.to_s if lhs.is_a?(Symbol)
+      #   rhs = rhs.to_s if rhs.is_a?(Symbol)
+
+      #   lhs == rhs
+      # RUBY
+
+      # row :a_comparison         , :gt                   , [] , "", <<-'RUBY'
+      #   lhs > rhs
+      # RUBY
+
+      # row :a_comparison         , :gte                  , [] , "", <<-'RUBY'
+      #   lhs >= rhs
+      # RUBY
+
+      # row :a_comparison         , :lt                   , [:less_than] , "# Lt: (less than) Block helper that renders a block if `a` is **less than** `b`. If an inverse block is specified it will be rendered when falsy.", <<-'RUBY'
+      #   lhs < rhs
+      # RUBY
+
+      # row :a_comparison         , :lte                  , [:less_than_or_equal_to] , "# Lte: (less than or equal to) Block helper that renders a block if `a` is **less than or equal to** `b`. If an inverse block is specified it will be rendered when falsy.", <<-'RUBY'
+      #   lhs <= rhs
+      # RUBY
+
+      # row :a_comparison         , :ne                   , [:not_equal] , "# Ne: (not equal) Block helper that renders a block if `a` is **not equal to** `b`. If an inverse block is specified it will be rendered when falsy.", <<-'RUBY'
+      #   lhs = lhs.to_s if lhs.is_a?(Symbol)
+      #   rhs = rhs.to_s if rhs.is_a?(Symbol)
+
+      #   lhs != rhs
+      # RUBY
+
+      # row :a_comparison         , :or                   , [:any] , "", <<-'RUBY'
+      #   values.any? { |value| value }
+      # RUBY
+
+      # row :a_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", <<-RUBY
+      #   return '' if value.nil?
+
+      #   value = value.to_i if value.is_a? String
+
+      #   value.ordinal
+      # RUBY
+
+      # row :a_inflection         , :ordinalize           , [] , "Turns a number into an ordinal string used to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.", <<-RUBY
+      #   return '' if value.nil?
+
+      #   value = value.to_i if value.is_a? String
+
+      #   value.ordinalize
+      # RUBY
+
+      # row :a_inflection         , :pluralize            , [] , "Returns the plural form of the word in the string", <<-RUBY
+      #   return '' if value.nil?
+
+      #   value = value.to_s if value.is_a?(Symbol)
+
+      #   value.pluralize
+      # RUBY
+
+      # row :a_inflection         , :pluralize_by_number  , [] , "Uses both a word and number to decide if the plural or singular form should be used.", <<-'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
+
+      # row :a_inflection         , :singularize          , [] , ""
+    end
   end
-end
 
-def nice_inputs(values)
-  values.map { |value| value.is_a?(String) ? "'#{value}'" : value }.join(', ')
-end
+  @commands = result.raw_data_struct.rows
+end
+@commands = nil

data/.builders/documents/use_cases.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 def use_cases
   return @use_cases unless @use_cases.nil?
-  
-  result = KDoc.model :document do
 
+  result = KDoc.model :document do
     # table :inputs do
     #   fields :name, :value
 
@@ -18,9 +19,9 @@ def use_cases
 
     # end
 
-    sentence1 = "The quick  brown fox, jumped  over the lazy dog"
-    sentence2 = "coyote and the acme company"
-    text1     = "the Quick brown Fox 99"
+    sentence1 = 'The quick  brown fox, jumped  over the lazy dog'
+    sentence2 = 'coyote and the acme company'
+    text1     = 'the Quick brown Fox 99'
 
     table :rows do
       # fields :category, :function, :input, :commands, :expected_value
@@ -62,37 +63,36 @@ def use_cases
       row :a_transform  , :title          , [text1]     , 'The Quick Brown Fox 99'
       row :a_transform  , :title          , [sentence1] , 'The Quick Brown Fox Jumped over the Lazy Dog'
       row :a_transform  , :upper          , [text1]     , 'THE QUICK BROWN FOX 99'
-      
 
       row :a_comparison , :and            , [nil, nil]        , false
       row :a_comparison , :and            , ['data', nil]     , false
       row :a_comparison , :and            , [nil, 'data']     , false
-      row :a_comparison , :and            , ['data', 'data']  , true
-      row :a_comparison , :and            , ['aaa', 'bbb']    , true
+      row :a_comparison , :and            , %w[data data]  , true
+      row :a_comparison , :and            , %w[aaa bbb]    , true
 
       # DEFAULT does not make sense in comparison
-      row :a_comparison , :default        , [nil, 'happy'] , "happy"
-      row :a_comparison , :default        , ['sad', 'happy'] , "sad"
-      row :a_comparison , :default        , [nil, nil, nil, nil, 'david'] , "david"
-      row :a_comparison , :default        , ['', 'happy'] , "happy"
+      row :a_comparison , :default        , [nil, 'happy'] , 'happy'
+      row :a_comparison , :default        , %w[sad happy] , 'sad'
+      row :a_comparison , :default        , [nil, nil, nil, nil, 'david'] , 'david'
+      row :a_comparison , :default        , ['', 'happy'] , 'happy'
 
       # type: :strict, :equiv, :cast, :insensitive
-      row :a_comparison , :eq             , [111, '111'  ], false
-      row :a_comparison , :eq             , [111, 111.0  ], false
-      row :a_comparison , :eq             , ['aaa', 'aaa'], true
-      row :a_comparison , :eq             , ['aaa', 'bbb'], false
-      row :a_comparison , :eq             , [:aaa,  :aaa] , true
+      row :a_comparison , :eq             , [111, '111'], false
+      row :a_comparison , :eq             , [111, 111.0], false
+      row :a_comparison , :eq             , %w[aaa aaa], true
+      row :a_comparison , :eq             , %w[aaa bbb], false
+      row :a_comparison , :eq             , %i[aaa aaa] , true
       row :a_comparison , :eq             , ['aaa', :aaa] , false
-      row :a_comparison , :eq             , ['aaa', 'bbb'], false
-      row :a_comparison , :eq             , ['aaa', 'AAA'], false
+      row :a_comparison , :eq             , %w[aaa bbb], false
+      row :a_comparison , :eq             , %w[aaa AAA], false
 
       row :a_comparison , :gt             , [2, 1] , true
       row :a_comparison , :gt             , [2, 2] , false
-      
+
       row :a_comparison , :gte            , [1, 2] , false
       row :a_comparison , :gte            , [1, 1] , true
       row :a_comparison , :gte            , [2, 1] , true
-      
+
       row :a_comparison , :lt             , [1, 2] , true
       row :a_comparison , :lt             , [2, 1] , false
 
@@ -102,16 +102,15 @@ def use_cases
 
       row :a_comparison , :ne             , [1, 2] , true
       row :a_comparison , :ne             , [1, 1] , false
-      
+
       row :a_comparison , :or             , [nil, nil]        , false
       row :a_comparison , :or             , ['data', nil]     , true
       row :a_comparison , :or             , [nil, 'data']     , true
-      row :a_comparison , :or             , ['data', 'data']  , true
-      row :a_comparison , :or             , ['aaa', 'bbb']    , true
+      row :a_comparison , :or             , %w[data data]  , true
+      row :a_comparison , :or             , %w[aaa bbb]    , true
       # row :text1          , %i[backslash]     , 'the\quick\brown\fox99'
       # row :text1          , %i[camel]         , 'TheQuickBrownFox99'
 
-
       # row :sentence3      , %i[plural]        , "jumped over the lazy dogs"
       # row :title          , %i[plural]        , "Account Categories"
       # row :sentence1      , %i[dash]          , "The-quick-brown-fox-jumped-over-the-lazy-dog"
@@ -120,17 +119,16 @@ def use_cases
       # row :bsb_account    , %i[lower snake]   , "abc_123"
       # row :bsb_account    , %i[slash]         , "ABC/123"
     end
-
   end
-  
+
   @use_cases = result.raw_data_struct.rows
 end
 @use_cases = nil
 
-  # def self.camel_case(string, tokenizer = PreservePrefixedUnderscoreTokenizer.new)
-  #   # DAVE INPUT 9 Oct 21 from lucky_case play
-  #   # dependency injection: to use enhanced tokenizer
-  #   a = split_case_string string
-  #   converted = ([a[0]] + a[1..-1].map { |e| capital e }).join('')
-  #   tokenizer.parse(converted)
-  # end
+# def self.camel_case(string, tokenizer = PreservePrefixedUnderscoreTokenizer.new)
+#   # DAVE INPUT 9 Oct 21 from lucky_case play
+#   # dependency injection: to use enhanced tokenizer
+#   a = split_case_string string
+#   converted = ([a[0]] + a[1..-1].map { |e| capital e }).join('')
+#   tokenizer.parse(converted)
+# end

data/.builders/documents/x_functions.rb

@@ -1,6 +1,6 @@
+# frozen_string_literal: true
 
 def category_blueprint
-
   fn_builder
     .init
     .category(:array      , active: 0 , title: 'Array'       , description: 'Functions for working with Array')
@@ -24,11 +24,9 @@ def category_blueprint
     .category(:regex      , active: 0 , title: 'Regex'       , description: 'Functions for working with Regex')
     .category(:string     , active: 0 , title: 'String'      , description: 'Functions for working with String')
     .category(:url        , active: 0 , title: 'Url'         , description: 'Functions for working with Url')
-
 end
 
 def function_blueprint
-
   fn_builder
     .init
     .for_category(:array)
@@ -41,11 +39,11 @@ def function_blueprint
     .for_category(:html)
     .for_category(:i18n)
     .for_category(:inflection)
-      .function(:ordinal)
-      .function(:ordinalize)
-      .function(:pluralize_by_number)
-      .function(:pluralize)
-      .function(:singularize)
+    .function(:ordinal)
+    .function(:ordinalize)
+    .function(:pluralize_by_number)
+    .function(:pluralize)
+    .function(:singularize)
     .for_category(:logging)
     .for_category(:markdown)
     .for_category(:match)
@@ -57,10 +55,9 @@ def function_blueprint
     .for_category(:regex)
     .for_category(:string)
     .for_category(:url)
-
 end
 
 # {{arrayify}}
 # Cast the given value to an array.
 # {{before}}
-# Return all of the items in the collection before the specified count. Opposite of after.
+# Return all of the items in the collection before the specified count. Opposite of after.