fylla 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 90d49bc51792ace89262f2175d3590427cdb9d92
-  data.tar.gz: 9cd74325c692ddce6371ddaea10d4e972ec721e2
+SHA256:
+  metadata.gz: dfe6f78127702957706d81b2d20f1433edb3d0539c2fe06cb7a5faa8a199dee1
+  data.tar.gz: c2aa3c67515e64eb9ea13c3177cc5f911bd65123438cda196df7a04781ee0a7e
 SHA512:
-  metadata.gz: a53727a1901bbe8cde4260fd3acaa75db30755b8fb8900cdaea12f6980028d9ef66b250ea6bc948b92e43460f3c5eeb27b4bad163d16a0480dbe5dce20876c32
-  data.tar.gz: d4adaac549e8dc82aad501442ad406ca8cb3d14594b0a1abb059f0c6b05893808e1d5b9b53bbf1941082936133567632344c6cd5ba682c90b5a42f16fdc1138d
+  metadata.gz: 39368c375eb8ccbc486609c06590e324e1aaa0980a071fa550c7898f6f1843a66a23320ec48a93d6b3d0dc7ecb29096a04d45be4b6eb2657108f0e505c5e2088
+  data.tar.gz: b6343092982862c13bcc149515a0d68a61623ca5a7790f41d4c0f3fa7406173549ecf2887d61a91e57bb6f57b080102fe09737074d04ab6da8a70873f7e38d31

data/Gemfile

@@ -1,4 +1,4 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in Fylla.gemspec
-gemspec
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in Fylla.gemspec
+gemspec

data/fylla.gemspec

@@ -1,39 +1,39 @@
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'fylla/version'
-
-# rubocop:disable BlockLength
-Gem::Specification.new do |spec|
-  spec.name = 'fylla'
-  spec.version = Fylla::VERSION
-  spec.authors = ['Tyler Thrailkill']
-  spec.email = ['tyler.b.thrailkill@gmail.com']
-
-  spec.summary = 'Adds functions for generating autocomplete scripts for Thor applications'
-  spec.description = 'Fylla generates zsh and bash autocomplete scripts for Thor CLI applications.'
-  spec.homepage = 'https://github.com/snowe2010/fylla'
-  spec.license = 'MIT'
-
-  spec.metadata['yard.run'] = 'yri' # use "yard" to build full HTML docs.
-  spec.metadata['changelog_uri'] = 'https://github.com/snowe2010/fylla/blob/master/CHANGELOG.md'
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      f.match(%r{^(.idea|test|spec|features)/|^[.][a-zA-Z0-9]|^.*[.]md|Gemfile.lock})
-    end
-  end
-
-  spec.bindir = 'exe'
-  spec.executables = spec.files.grep(%r{^exe/}) {|f| File.basename(f)}
-  spec.require_paths = ['lib']
-
-  spec.add_development_dependency 'bundler', '~> 2.0'
-  spec.add_development_dependency 'codecov', '~> 0.1.14'
-  spec.add_development_dependency 'minitest', '~> 5.0'
-  spec.add_development_dependency 'minitest-hooks', '~> 1.5.0'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_dependency 'thor', '>= 0.19.0'
-end
-# rubocop:enable BlockLength
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fylla/version'
+
+# rubocop:disable BlockLength
+Gem::Specification.new do |spec|
+  spec.name = 'fylla'
+  spec.version = Fylla::VERSION
+  spec.authors = ['Tyler Thrailkill']
+  spec.email = ['tyler.b.thrailkill@gmail.com']
+
+  spec.summary = 'Adds functions for generating autocomplete scripts for Thor applications'
+  spec.description = 'Fylla generates zsh and bash autocomplete scripts for Thor CLI applications.'
+  spec.homepage = 'https://github.com/snowe2010/fylla'
+  spec.license = 'MIT'
+
+  spec.metadata['yard.run'] = 'yri' # use "yard" to build full HTML docs.
+  spec.metadata['changelog_uri'] = 'https://github.com/snowe2010/fylla/blob/master/CHANGELOG.md'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{^(.idea|test|spec|features)/|^[.][a-zA-Z0-9]|^.*[.]md|Gemfile.lock})
+    end
+  end
+
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{^exe/}) {|f| File.basename(f)}
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'codecov', '~> 0.1.14'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'minitest-hooks', '~> 1.5.0'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_dependency 'thor', '>= 0.19.0'
+end
+# rubocop:enable BlockLength

data/lib/fylla.rb

@@ -5,6 +5,9 @@ require 'fylla/parsed_subcommand'
 require 'fylla/completion_extension'
 require 'thor'
 
+# We _must prepend before thor loads_ Ideally this is at require time...
+::Thor::Option.prepend Fylla::Thor::Option
+
 #
 # Top level module for the Fylla project.
 # Contains one method for initializing Fylla
@@ -18,7 +21,6 @@ module Fylla
   def self.load(executable_name = nil)
     @executable_name = executable_name || nil
     ::Thor.prepend Fylla::Thor::CompletionGenerator
-    # ::Thor::Option.prepend Fylla::Thor::Option
   end
 
   #

data/lib/fylla/completion_extension.rb

@@ -1,21 +1,15 @@
-require 'thor'
-
-class Thor
-  class Option
-    attr_accessor :completion
-    old_initialize = instance_method(:initialize)
-    define_method(:initialize) do |name, options = {}|
-      old_initialize.bind(self).call(name, options)
-      @completion = options[:completion]
-    end
-    # def initialize(name, options = {})
-    #   old_initialize
-    # end
-
-    class << self
-      def completion(completion)
-        @completion = completion
-      end
-    end
-  end
-end
+require 'thor'
+
+# add the 'completion:' option to Thor::Option, which
+# allows passing a shorter description for the shell
+module Fylla
+  module Thor
+    module Option
+      attr_accessor :completion
+      def initialize(name, options = {})
+        @completion = options[:completion]
+        super
+      end
+    end
+  end
+end

data/lib/fylla/completion_generator.rb

@@ -1,184 +1,184 @@
-require_relative 'parsed_option'
-require_relative 'parsed_command'
-require_relative 'parsed_subcommand'
-require 'erb'
-
-module Fylla
-  module Thor
-    #
-    # module for prepending into +Thor+
-    # inserts methods into Thor that allow generating completion scripts
-    module CompletionGenerator
-      def self.prepended(base)
-        base.singleton_class.prepend(ClassMethods)
-      end
-
-      #
-      # Contains the methods +zsh_completion+
-      module ClassMethods
-        #
-        # Generates a zsh _[executable_name] completion
-        # script for the entire Thor application
-        #
-        # @param executable_name [String]
-        #   the name of the executable to generate the script for
-        def zsh_completion(executable_name)
-          @executable_name = executable_name
-          command = create_command_map all_commands, subcommand_classes
-
-          builder = map_to_completion_string [command]
-          completion = "#compdef _#{executable_name} #{executable_name}\n"
-          completion += builder
-          completion
-        end
-
-        #
-        # Generates a bash _[executable_name] completion
-        # script for the entire Thor application
-        #
-        # @param executable_name [String]
-        #   the name of the executable to generate the script for
-        def bash_completion(executable_name)
-          @executable_name = executable_name
-          command = create_command_map all_commands, subcommand_classes
-
-          builder = map_to_completion_string [command], style: :bash
-          completion = ''
-          completion += builder
-          completion += "complete -F _#{executable_name} #{executable_name}\n"
-          completion
-        end
-
-        private
-
-        # Takes a list of [ParsedCommand]s and [ParsedSubcommand]s
-        # and converts them into completion strings, to be combined
-        # together into one completion script
-        #
-        # @param style [Symbol] style of completions to generate
-        #   defaults to :zsh
-        # @param commands [List<Thor::Command>]
-        #   list of [Thor::Command]s
-        # @param context [String] the current command context
-        #   this is essentially a breadcrumb of our current
-        #   command path:
-        #     e.g. "exe sub1 sub2 sub3 --help" maps to a context of
-        #          "_sub1_sub2_sub3"
-        # @param class_options [List<Thor::Option>]
-        #   a list of global or class level options for the current context
-        def map_to_completion_string(commands,
-                                     context: '',
-                                     class_options: [],
-                                     style: :zsh)
-          builder = ''
-          commands.each do |command|
-            context_name = generate_context_name(context, command)
-            result = generate_completion_string(command, class_options, context_name, style)
-            builder += result
-          end
-          builder
-        end
-
-        # Generate a context name based off of
-        # the current context and the current command
-        #
-        # @param context [String] the current context
-        # @param command [Thor::Command]
-        #   current command we are generating documentation for
-        def generate_context_name(context, command)
-          command_name = if command.name.nil? || command.name.empty?
-                           ''
-                         else
-                           "_#{command.name}"
-                         end
-          "#{context}#{command_name}"
-        end
-
-        def generate_completion_string(command, class_options, context_name, style)
-          builder = ''
-          if command.is_a? ParsedSubcommand
-            class_options = (class_options + command.class_options).uniq
-            builder += map_to_completion_string(command.commands,
-                                                context: context_name,
-                                                class_options: class_options,
-                                                style: style)
-
-            builder += create_completion_string(read_template(style, :subcommand), binding)
-          else
-            builder += create_completion_string(read_template(style, :command), binding)
-          end
-          builder
-        end
-
-        # Recursively generate a command map based off
-        # of the commands and subcommands passed in.
-        #
-        # The [command_map] is a map of [String]s to [Thor::Command] objects,
-        # while the [subcommand_map] is a map of [String]s to [Thor] classes,
-        # usually your own CLI classes that subclass [Thor]
-        #
-        # @param command_map [Hash<String, Thor::Command>]
-        #   a map to recursively generate a completion layout
-        # @param subcommand_map [Hash<String, Class < Thor>]
-        #   a map indicating the subcommands and their respective classes
-        def recursively_find_commands(command_map, subcommand_map)
-          map = Hash[command_map.map {|k, v| [v, subcommand_map[k]]}]
-          map.map do |command, subcommand_class|
-            if subcommand_class.nil?
-              ancestor_name = command.ancestor_name if command.respond_to? :ancestor_name
-              options = parse_options(command.options.values)
-              ParsedCommand.new(ancestor_name, command.description, command.name, options)
-            else
-              commands = recursively_find_commands subcommand_class.commands, subcommand_class.subcommand_classes
-              ParsedSubcommand.new(command.name, command.description, commands, subcommand_class.class_options.values)
-            end
-          end
-        end
-
-        # Top level method to begin the recursive map generation
-        # This is needed because we don't have a 'top' level
-        # command to wrap everything under.
-        #
-        # This simplifies the rest of the code.
-        #
-        # (see #recursively_find_commands) for more documentation
-        def create_command_map(command_map, subcommand_map)
-          command_map = recursively_find_commands command_map, subcommand_map
-          ParsedSubcommand.new(nil, '', command_map, class_options.values)
-        end
-
-        # Helper method to load an [ERB] template
-        # and generate the corresponding [String]
-        #
-        # @param template [String] an ERB template
-        # @param bind [Binding] a binding to a context
-        def create_completion_string(template, bind)
-          template = ERB.new(template, nil, '-<>')
-          template.result(bind)
-        end
-
-        # Helper method to read an [ERB] template
-        # from a file and return it as a [String]
-        #
-        # @param name [Symbol] type of template to retrieve
-        #   can be either :subcommand or :command
-        # @param style [Symbol] style of template to retrieve
-        #   can be either :zsh or :bash
-        # @return [String] template string retrieved from erb file
-        def read_template(style, name)
-          style = style.is_a?(Symbol) ? style.to_s : style
-          name = name.is_a?(Symbol) ? name.to_s : name
-          erb_path = "erb_templates/#{style}/#{name}.erb"
-          File.read(File.join(__dir__, erb_path))
-        end
-
-        def parse_options(options)
-          options.map do |opt|
-            description = opt.completion || opt.description || opt.banner
-            ParsedOption.new(opt.name, description, opt.aliases)
-          end
-        end
-      end
-    end
-  end
-end
+require_relative 'parsed_option'
+require_relative 'parsed_command'
+require_relative 'parsed_subcommand'
+require 'erb'
+
+module Fylla
+  module Thor
+    #
+    # module for prepending into +Thor+
+    # inserts methods into Thor that allow generating completion scripts
+    module CompletionGenerator
+      def self.prepended(base)
+        base.singleton_class.prepend(ClassMethods)
+      end
+
+      #
+      # Contains the methods +zsh_completion+
+      module ClassMethods
+        #
+        # Generates a zsh _[executable_name] completion
+        # script for the entire Thor application
+        #
+        # @param executable_name [String]
+        #   the name of the executable to generate the script for
+        def zsh_completion(executable_name)
+          @executable_name = executable_name
+          command = create_command_map all_commands, subcommand_classes
+
+          builder = map_to_completion_string [command]
+          completion = "#compdef _#{executable_name} #{executable_name}\n"
+          completion += builder
+          completion
+        end
+
+        #
+        # Generates a bash _[executable_name] completion
+        # script for the entire Thor application
+        #
+        # @param executable_name [String]
+        #   the name of the executable to generate the script for
+        def bash_completion(executable_name)
+          @executable_name = executable_name
+          command = create_command_map all_commands, subcommand_classes
+
+          builder = map_to_completion_string [command], style: :bash
+          completion = ''
+          completion += builder
+          completion += "complete -F _#{executable_name} #{executable_name}\n"
+          completion
+        end
+
+        private
+
+        # Takes a list of [ParsedCommand]s and [ParsedSubcommand]s
+        # and converts them into completion strings, to be combined
+        # together into one completion script
+        #
+        # @param style [Symbol] style of completions to generate
+        #   defaults to :zsh
+        # @param commands [List<Thor::Command>]
+        #   list of [Thor::Command]s
+        # @param context [String] the current command context
+        #   this is essentially a breadcrumb of our current
+        #   command path:
+        #     e.g. "exe sub1 sub2 sub3 --help" maps to a context of
+        #          "_sub1_sub2_sub3"
+        # @param class_options [List<Thor::Option>]
+        #   a list of global or class level options for the current context
+        def map_to_completion_string(commands,
+                                     context: '',
+                                     class_options: [],
+                                     style: :zsh)
+          builder = ''
+          commands.each do |command|
+            context_name = generate_context_name(context, command)
+            result = generate_completion_string(command, class_options, context_name, style)
+            builder += result
+          end
+          builder
+        end
+
+        # Generate a context name based off of
+        # the current context and the current command
+        #
+        # @param context [String] the current context
+        # @param command [Thor::Command]
+        #   current command we are generating documentation for
+        def generate_context_name(context, command)
+          command_name = if command.name.nil? || command.name.empty?
+                           ''
+                         else
+                           "_#{command.name}"
+                         end
+          "#{context}#{command_name}"
+        end
+
+        def generate_completion_string(command, class_options, context_name, style)
+          builder = ''
+          if command.is_a? ParsedSubcommand
+            class_options = (class_options + command.class_options).uniq
+            builder += map_to_completion_string(command.commands,
+                                                context: context_name,
+                                                class_options: class_options,
+                                                style: style)
+
+            builder += create_completion_string(read_template(style, :subcommand), binding)
+          else
+            builder += create_completion_string(read_template(style, :command), binding)
+          end
+          builder
+        end
+
+        # Recursively generate a command map based off
+        # of the commands and subcommands passed in.
+        #
+        # The [command_map] is a map of [String]s to [Thor::Command] objects,
+        # while the [subcommand_map] is a map of [String]s to [Thor] classes,
+        # usually your own CLI classes that subclass [Thor]
+        #
+        # @param command_map [Hash<String, Thor::Command>]
+        #   a map to recursively generate a completion layout
+        # @param subcommand_map [Hash<String, Class < Thor>]
+        #   a map indicating the subcommands and their respective classes
+        def recursively_find_commands(command_map, subcommand_map)
+          map = Hash[command_map.map {|k, v| [v, subcommand_map[k]]}]
+          map.map do |command, subcommand_class|
+            if subcommand_class.nil?
+              ancestor_name = command.ancestor_name if command.respond_to? :ancestor_name
+              options = parse_options(command.options.values)
+              ParsedCommand.new(ancestor_name, command.description, command.name, options)
+            else
+              commands = recursively_find_commands subcommand_class.commands, subcommand_class.subcommand_classes
+              ParsedSubcommand.new(command.name, command.description, commands, subcommand_class.class_options.values)
+            end
+          end
+        end
+
+        # Top level method to begin the recursive map generation
+        # This is needed because we don't have a 'top' level
+        # command to wrap everything under.
+        #
+        # This simplifies the rest of the code.
+        #
+        # (see #recursively_find_commands) for more documentation
+        def create_command_map(command_map, subcommand_map)
+          command_map = recursively_find_commands command_map, subcommand_map
+          ParsedSubcommand.new(nil, '', command_map, class_options.values)
+        end
+
+        # Helper method to load an [ERB] template
+        # and generate the corresponding [String]
+        #
+        # @param template [String] an ERB template
+        # @param bind [Binding] a binding to a context
+        def create_completion_string(template, bind)
+          template = ERB.new(template, nil, '-<>')
+          template.result(bind)
+        end
+
+        # Helper method to read an [ERB] template
+        # from a file and return it as a [String]
+        #
+        # @param name [Symbol] type of template to retrieve
+        #   can be either :subcommand or :command
+        # @param style [Symbol] style of template to retrieve
+        #   can be either :zsh or :bash
+        # @return [String] template string retrieved from erb file
+        def read_template(style, name)
+          style = style.is_a?(Symbol) ? style.to_s : style
+          name = name.is_a?(Symbol) ? name.to_s : name
+          erb_path = "erb_templates/#{style}/#{name}.erb"
+          File.read(File.join(__dir__, erb_path))
+        end
+
+        def parse_options(options)
+          options.map do |opt|
+            description = opt.completion || opt.description || opt.banner
+            ParsedOption.new(opt.name, description, opt.aliases)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fylla/erb_templates/bash/command.erb

@@ -1,14 +1,14 @@
-_<%= @executable_name %><%= context_name %> ()
-{
-  local cur="${COMP_WORDS[COMP_CWORD]}"
-  local options=()
-  <%- command.options.each do |opt| -%>
-    options+=("--<%= opt.name %>")
-    <%- opt.aliases.each do |a| -%>
-    options+=("-<%= a %>")
-    <%- end -%>
-  <%- end -%>
-  options+=("--help")
-  options+=("-h")
-  COMPREPLY=($(compgen -W "${options[*]}" -- "$cur"))
-}
+_<%= @executable_name %><%= context_name %> ()
+{
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  local options=()
+  <%- command.options.each do |opt| -%>
+    options+=("--<%= opt.name %>")
+    <%- opt.aliases.each do |a| -%>
+    options+=("-<%= a %>")
+    <%- end -%>
+  <%- end -%>
+  options+=("--help")
+  options+=("-h")
+  COMPREPLY=($(compgen -W "${options[*]}" -- "$cur"))
+}

data/lib/fylla/erb_templates/bash/subcommand.erb

@@ -1,36 +1,36 @@
-_<%= @executable_name %><%= context_name %>() {
-  local i=1 subcommand_index
-
-  # find the subcommand
-  while [[ $i -lt $COMP_CWORD ]]; do
-    local s="${COMP_WORDS[i]}"
-    case "$s" in
-    <%= command.name || @executable_name %>)<%# if command.name is empty, then we're at the top level command. therefore we need to use the @executable_name %>
-      subcommand_index=$i
-      break
-      ;;
-    esac
-    (( i++ ))
-  done
-
-  while [[ $subcommand_index -lt $COMP_CWORD ]]; do
-    local s="${COMP_WORDS[subcommand_index]}"
-    case "$s" in
-      <%- unless command.commands.empty? -%>
-        <%- command.commands.each do |command| -%>
-          <%= command.name %>)
-            _<%= @executable_name %><%= context_name %>_<%= command.name %>
-            return ;;
-        <%- end -%>
-      <%- end -%>
-      help)
-        COMPREPLY=""
-        return
-        ;;
-    esac
-    (( subcommand_index++ ))
-  done
-
-  local cur="${COMP_WORDS[COMP_CWORD]}"
-  COMPREPLY=($(compgen -W "<%= command.commands.map(&:name).join(" ") %> <%= command.class_options.map(&:switch_name).join(" ") %>" -- "$cur"))
-}
+_<%= @executable_name %><%= context_name %>() {
+  local i=1 subcommand_index
+
+  # find the subcommand
+  while [[ $i -lt $COMP_CWORD ]]; do
+    local s="${COMP_WORDS[i]}"
+    case "$s" in
+    <%= command.name || @executable_name %>)<%# if command.name is empty, then we're at the top level command. therefore we need to use the @executable_name %>
+      subcommand_index=$i
+      break
+      ;;
+    esac
+    (( i++ ))
+  done
+
+  while [[ $subcommand_index -lt $COMP_CWORD ]]; do
+    local s="${COMP_WORDS[subcommand_index]}"
+    case "$s" in
+      <%- unless command.commands.empty? -%>
+        <%- command.commands.each do |command| -%>
+          <%= command.name %>)
+            _<%= @executable_name %><%= context_name %>_<%= command.name %>
+            return ;;
+        <%- end -%>
+      <%- end -%>
+      help)
+        COMPREPLY=""
+        return
+        ;;
+    esac
+    (( subcommand_index++ ))
+  done
+
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  COMPREPLY=($(compgen -W "<%= command.commands.map(&:name).join(" ") %> <%= command.class_options.map(&:switch_name).join(" ") %>" -- "$cur"))
+}

data/lib/fylla/erb_templates/zsh/subcommand.erb

@@ -16,9 +16,9 @@ function _<%= @executable_name %><%= context_name %> {
   <%- unless class_options.nil? -%>
     <%- class_options.each do |option| -%>
       <%- option.aliases.each do |al| -%>
-        "-<%= al %>=[<%= option.description %>]" \
+    "-<%= al %>=[<%= option.description %>]" \
       <%- end -%>
-      "--<%= option.name%>=[<%= option.description %>]" \
+    "--<%= option.name%>=[<%= option.description %>]" \
     <%- end -%>
   <%- end -%>
     "-h[Show help information]" \

data/lib/fylla/thor/extensions/ShellDescriptionExtension.rb

@@ -0,0 +1 @@
+

data/lib/fylla/version.rb

@@ -1,3 +1,3 @@
 module Fylla
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.4.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fylla
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Tyler Thrailkill
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-02-03 00:00:00.000000000 Z
+date: 2019-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -119,6 +119,7 @@ files:
 - lib/fylla/parsed_command.rb
 - lib/fylla/parsed_option.rb
 - lib/fylla/parsed_subcommand.rb
+- lib/fylla/thor/extensions/ShellDescriptionExtension.rb
 - lib/fylla/version.rb
 homepage: https://github.com/snowe2010/fylla
 licenses:
@@ -142,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14.1
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Adds functions for generating autocomplete scripts for Thor applications