Support keyword arguments partially

.rubocop.yml

@@ -2,11 +2,14 @@ AllCops:
   Exclude:
     - vendor/**/*
 
-Style/AccessModifierIndentation:
-  EnforcedStyle: outdent
-
 Style/AndOr:
   Enabled: false
 
+Style/LambdaCall:
+  Enabled: false
+
 Style/TrailingComma:
   Enabled: false
+
+Style/AccessModifierIndentation:
+  EnforcedStyle: outdent

README.md

@@ -22,9 +22,27 @@ gem 'lita-random', '~> 0.5.1'
 
 ### Commands
 
-The space between instructions can be skiiped, so you can write
+The space between instructions can be skipped, so you can write
 `random hex` as `randomhex`, `rand b64` as `randb64`
 
+Arguments for all commands (excluding `random case`, `shuffle` and `sample`)
+can be passed as keyword arguments too. Put them after
+positional arguments with two dashes before, or the first letter
+of argument name with one dash. Examples:
+
+```
+You: lita random 5 10
+Lita: 7
+You: lita random 5 --to 5
+Lita: 9
+You: lita random 5 -t 10
+Lita: 5
+You: lita random --to 10 --from 5
+Lita: 6
+You: lita random -f 5 -t 10
+Lita: 9
+```
+
 Command `random` has alias `rand`
 
 * `random` -
@@ -36,19 +54,19 @@ Command `random` has alias `rand`
 * `random <from> <to>` -
   random integer or float number, greater or equal to `from` and lesser than `to`
 
-* `random case <s>` -
-  randomize case of each character of string `s`
+* `random case <string>` -
+  randomize case of each character of string `string`
 
 Command `base64` has alias `b64`
 
-* `random base64 <n=16>` -
-  random base64 string, length of source string is `n`,
-  length of result is about `n * 4 / 3` (24 with default value of `n`)
+* `random base64 <size=16>` -
+  random base64 string, length of source string is `size`,
+  length of result is about `size * 4 / 3` (24 with default value of `size`)
 
 Command `hex` has aliases `hx` and `x`
 
-* `random hex <n=16>` -
-  random hexadecimal string with length `n * 2`
+* `random hex <size=16>` -
+  random hexadecimal string with length `size * 2`
 
 Command `uuid` has alias `uid`
 
@@ -59,18 +77,18 @@ Command `uuid` has alias `uid`
 
 Command `password` has alias `pass`
 
-* `random password <n=16>` -
-  random password with length `n` containing characters
+* `random password <length=16>` -
+  random password with length `length` containing characters
   in upper and lower case, and digits
 
-* `random smart password <n=8>` -
-  random pronounceable password with a minimum length of `n`
+* `random smart password <length=8>` -
+  random pronounceable password with a minimum length of `length`
 
 * `shuffle <array, ...>` -
   new array with elements of `array` shuffled
 
-* `sample <n=1> <array, ...>` -
-  choose `n` random elements from `array`
+* `sample <count=1> <array, ...>` -
+  choose `count` random elements from `array`
 
 ### Examples
 
@@ -82,12 +100,12 @@ Lita: 0.8332672468501509
 
 You: lita random 5
 Lita: 2
-You: lita rand 100
+You: lita rand --to 100
 Lita: 24
 
-You: lita random 1.5
+You: lita random -f 1.5
 Lita: 1.1828046952104034
-You: lita random 5 10
+You: lita random 10 --from 5
 Lita: 8
 You: lita rand 1000 2000
 Lita: 1240
@@ -104,15 +122,15 @@ Lita: NMkIhB+iG2VNpg==
 
 You: lita random hex
 Lita: 7d6f39cf53303db862bac5e1b36eb0fa
-You: lita randx 10
+You: lita randx -s 10
 Lita: 0d8297837d6e63b8c25b
 
 You: lita random uuid
 Lita: f1281565-3c8a-475d-a1aa-565ff840a42c
 
 You: lita random password
 Lita: TXXBu7XEBdwFF7fP
-You: lita randpass 8
+You: lita randpass --length 8
 Lita: 7lFateFs
 
 You: lita random smart password

lib/lita/handlers/random.rb

@@ -1,3 +1,5 @@
+require 'lita-keyword-arguments'
+
 ##
 # Lita module.
 #
@@ -22,72 +24,61 @@ class Random < Handler # rubocop:disable Metrics/ClassLength
           'random integer or float number, ' \
           'greater or equal to `from` and lesser than `to`',
 
-        'random case <s>' =>
-          'randomize case of each character of string `s`',
+        'random case <string>' =>
+          'randomize case of each character of string `string`',
 
-        'random base64 <n=16>' =>
-          'random base64 string, length of source string is n, ' \
-          'length of result is about `n * 4 / 3` ' \
-          '(24 with default value of `n`)',
+        'random base64 <size=16>' =>
+          'random base64 string, length of source string is `size`, ' \
+          'length of result is about `size * 4 / 3` ' \
+          '(24 with default value of `size`)',
 
-        'random hex <n=16>' =>
-          'random hexadecimal string with length `n * 2`',
+        'random hex <size=16>' =>
+          'random hexadecimal string with length `size * 2`',
 
         'random uuid' =>
           'v4 random UUID (Universally Unique IDentifier). ' \
           'The version 4 UUID is purely random (except the version). ' \
           'It doesn’t contain meaningful information ' \
           'such as MAC address, time, etc.',
 
-        'random password <n=16>' =>
-          'random password with length `n` containing characters ' \
+        'random password <length=16>' =>
+          'random password with length `length` containing characters ' \
           'in upper and lower case, and digits',
 
-        'random smart password <n=8>' =>
-          'random pronounceable password with a minimum length of `n`',
+        'random smart password <length=8>' =>
+          'random pronounceable password with a minimum length of `length`',
 
         'shuffle <array, ...>' =>
           'new array with elements of `array` shuffled',
 
-        'sample <n=1> <array, ...>' =>
-          'choose `n` random elements from `array`',
+        'sample <count=1> <array, ...>' =>
+          'choose `count` random elements from `array`',
       }
 
-      route(/^rand(om)?$/i, :route_random, command: true, help: HELP)
-      def route_random(response)
-        response.reply(::Random.rand.to_s)
-      end
-
-      route(/^rand(om)?\s+(\d+)?$/i, :route_random_to, command: true)
-      def route_random_to(response)
-        to = response.matches[0][1].to_i
-        response.reply(::Random.rand(to).to_s)
-      end
-
-      route(/^rand(om)?\s+(\d+\.\d+)?$/i, :route_random_float_to, command: true)
-      def route_random_float_to(response)
-        to = response.matches[0][1].to_f
-        response.reply(::Random.rand(to).to_s)
-      end
+      route(
+        /^rand(om)?((\s+(?<from>\d+(\.\d+)?))?\s+(?<to>\d+(\.\d+)?))?($|\s*-)/i,
+        :route_random,
+        command: true, help: HELP,
+        kwargs: {
+          from: { short: 'f' },
+          to: { short: 't' },
+        }
+      )
 
-      route(/^rand(om)?\s+(\d+)\s+(\d+)?$/i,
-            :route_random_from_to, command: true)
-      def route_random_from_to(response)
-        from = response.matches[0][1].to_i
-        to = response.matches[0][2].to_i
-        response.reply(::Random.rand(from...to).to_s)
-      end
+      def route_random(response)
+        from = extract_argument(response, 0, :from, &method(:str_to_num)) || 0
+        to = extract_argument(response, 1, :to, &method(:str_to_num)) || 1.0
+
+      rescue RuntimeError # rubocop:disable Lint/HandleExceptions
+      else
+        result = if from.is_a?(Float) || to.is_a?(Float)
+                   # In Rubinius,
+                   # ::Random.rand can not exclude non Integer end value
+                   ::Random.rand(from..(to - Float::EPSILON))
+                 else
+                   ::Random.rand(from...to)
+                 end
 
-      route(/^rand(om)?\s+(?<from>\d+\.\d+)\s+(?<to>\d+)?$/i,
-            :route_random_float_from_to, command: true)
-      route(/^rand(om)?\s+(?<from>\d+(\.\d+)?)\s+(?<to>\d+\.\d+)?$/i,
-            :route_random_float_from_to, command: true)
-      def route_random_float_from_to(response)
-        matches = response.matches[0]
-        from = matches[0].to_f
-        to = matches[1].to_f
-        # In Rubinius, ::Random.rand can not exclude non Integer end value
-        result = ::Random.rand(from..(to - Float::EPSILON))
         response.reply(result.to_s)
       end
 
@@ -97,57 +88,76 @@ def route_random_case(response)
         response.reply(random_case(response.matches[0][0] || ''))
       end
 
-      route(/^rand(om)?\s*b(ase)?64$/i, :route_random_base64, command: true)
+      route(
+        /^rand(om)?\s*b(ase)?64(\s+(?<n>\d+))?($|\s)/i,
+        :route_random_base64,
+        command: true,
+        kwargs: {
+          size: { short: 's' },
+        }
+      )
+
       def route_random_base64(response)
-        response.reply(SecureRandom.base64)
-      end
+        size = extract_argument(response, 0, :size, &:to_i) || 16
 
-      route(/^rand(om)?\s*b(ase)?64\s+(?<n>\d+)$/i,
-            :route_random_base64_n, command: true)
-      def route_random_base64_n(response)
-        n = response.matches[0][0].to_i
-        response.reply(SecureRandom.base64(n))
+      rescue RuntimeError # rubocop:disable Lint/HandleExceptions
+      else
+        response.reply(SecureRandom.base64(size))
       end
 
-      route(/^rand(om)?\s*(he?)?x$/i, :route_random_hex, command: true)
+      route(
+        /^rand(om)?\s*(he?)?x(\s+(?<n>\d+))?($|\s)/i,
+        :route_random_hex,
+        command: true,
+        kwargs: {
+          size: { short: 's' },
+        }
+      )
+
       def route_random_hex(response)
-        response.reply(SecureRandom.hex)
-      end
+        size = extract_argument(response, 0, :size, &:to_i) || 16
 
-      route(/^rand(om)?\s*(he?)?x\s+(?<n>\d+)$/i,
-            :route_random_hex_n, command: true)
-      def route_random_hex_n(response)
-        n = response.matches[0][0].to_i
-        response.reply(SecureRandom.hex(n))
+      rescue RuntimeError # rubocop:disable Lint/HandleExceptions
+      else
+        response.reply(SecureRandom.hex(size))
       end
 
       route(/^rand(om)?\s*u?uid$/i, :route_random_uuid, command: true)
       def route_random_uuid(response)
         response.reply(SecureRandom.uuid)
       end
 
-      route(/^rand(om)?\s*smart\s*pass(word)?$/i,
-            :route_random_smart_pass, command: true)
+      route(
+        /^rand(om)?\s*smart\s*pass(word)?(\s+(?<n>\d+))?($|\s)/i,
+        :route_random_smart_pass,
+        command: true,
+        kwargs: {
+          length: { short: 'l' },
+        }
+      )
+
       def route_random_smart_pass(response)
-        response.reply(smart_password)
-      end
+        length = extract_argument(response, 0, :length, &:to_i) || 8
 
-      route(/^rand(om)?\s*smart\s*pass(word)?\s+(?<n>\d+)$/i,
-            :route_random_smart_pass_n, command: true)
-      def route_random_smart_pass_n(response)
-        min_length = response.matches[0][0].to_i
-        response.reply(smart_password(min_length))
+      rescue RuntimeError # rubocop:disable Lint/HandleExceptions
+      else
+        response.reply(smart_password(length))
       end
 
-      route(/^rand(om)?\s*pass(word)?$/i, :route_random_pass, command: true)
+      route(
+        /^rand(om)?\s*pass(word)?(\s+(?<n>\d+))?($|\s)/i,
+        :route_random_pass,
+        command: true,
+        kwargs: {
+          length: { short: 'l' },
+        }
+      )
+
       def route_random_pass(response)
-        response.reply(password)
-      end
+        length = extract_argument(response, 0, :length, &:to_i) || 16
 
-      route(/^rand(om)?\s*pass(word)?\s+(?<n>\d+)$/i,
-            :route_random_pass_n, command: true)
-      def route_random_pass_n(response)
-        length = response.matches[0][0].to_i
+      rescue RuntimeError # rubocop:disable Lint/HandleExceptions
+      else
         response.reply(password(length))
       end
 
@@ -185,7 +195,7 @@ def random_case(s)
         true => %w(a e i o u y),
       }
 
-      def smart_password(min_length = 8)
+      def smart_password(min_length)
         password = ''
         sequence_id = false
         while password.length < min_length
@@ -198,9 +208,27 @@ def smart_password(min_length = 8)
 
       PASS_CHARS = [*'a'..'z', *'A'..'Z', *'0'..'9']
 
-      def password(length = 16)
+      def password(length)
         (0...length).map { |_| PASS_CHARS.sample }.join
       end
+
+      def extract_argument(response, index, name)
+        matches = response.matches[0]
+        kwargs = response.extensions[:kwargs]
+
+        positional = matches[index]
+        kw = kwargs[name]
+
+        fail if positional && kw
+
+        s = positional || kw
+
+        block_given? && s ? yield(s) : s
+      end
+
+      def str_to_num(s)
+        s =~ /\./ ? s.to_f : s.to_i
+      end
     end
 
     Lita.register_handler(Random)