kafo_wizards 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0f658c648e658e6378f3051e127e57204ea368e3
+  data.tar.gz: d985f2ac7a37638007bd9f0ea649d0c26a936545
+SHA512:
+  metadata.gz: 6215f0b624883378e803fdd82d7608ba84d2de1dad1b18182b80b9052b5cf9065060b37cd679c5c6581febb234b7865bed15f5f43038179279448676d4b0d9c7
+  data.tar.gz: 53fdddf5193a3eee0782ad2759c2a5b6e150b475e038b1c8758dd501c98a7b7f9305f34acf042e7a94604c576aef172301b8f87aa5cba38a995059b22bfeb8f6

data/LICENSE.txt

@@ -0,0 +1,11 @@
+This program and entire repository is free software: you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation, either version 3 of the License,
+or any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+this program. If not, see http://www.gnu.org/licenses/.

data/README.md

@@ -0,0 +1,88 @@
+# KafoWizards
+
+
+With this gem it is possible to define form or wizard and display it to the user using one of the defined backends. The form definition is independent on the chosen backend so it can be changed freely. Currently only command line (highline) backend is implemented, YAD or web based backend is planed.
+
+Warning: The code is still very unstable
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'kafo_wizards'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kafo_wizards
+
+## Usage
+
+```ruby
+require 'kafo_wizards'
+require 'awesome_print'
+
+wizard = KafoWizards.wizard(:cli, 'Register',
+  :description => "Please provide credentials for a new account")
+
+f = wizard.factory
+
+wizard.entries = [
+  f.string(:username, :default_value => 'admin', :required => true),
+  f.password(:password, :label => 'Password', :confirmation_required => true, :required => true),
+  f.button(:register, :label => 'Register new account', :default => true),
+  f.button(:cancel, :default => false, :trigger_validation => false)
+]
+
+res = wizard.run
+
+puts "Submitted with #{res.ai}"
+puts "Values: #{wizard.values.ai}"
+```
+
+will render as:
+
+```text
+Register
+                *Username: 'admin'
+                *Password: **********
+
+Please provide credentials for a new account
+
+Available actions:
+1. Register new account
+2. Change Username
+3. Change Password
+4. Cancel
+Your choice: 3
+Enter new password: ********
+Re-type new password: ********
+
+Register
+                *Username: 'admin'
+                *Password: **********
+
+Please provide credentials for a new account
+
+Available actions:
+1. Register new account
+2. Change Username
+3. Change Password
+4. Cancel
+Your choice: 1
+Submitted with :register
+Values: {
+    :username => "admin",
+    :password => "changeme"
+}
+
+```
+
+For more examples look into `doc/examples/` directory.
+
+# License
+
+This project is licensed under the GPLv3+.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake/testtask'
+require "bundler/gem_tasks"
+load 'tasks/jenkins.rake'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib' << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+

data/lib/kafo_wizards.rb

@@ -0,0 +1,7 @@
+require 'kafo_wizards/version'
+require 'kafo_wizards/exceptions'
+require 'kafo_wizards/entries'
+require 'kafo_wizards/abstract_wizard'
+require 'kafo_wizards/highline'
+require 'kafo_wizards/factory'
+

data/lib/kafo_wizards/abstract_wizard.rb

@@ -0,0 +1,104 @@
+require 'logger'
+
+module KafoWizards
+  class AbstractWizard
+    attr_reader :header, :description, :logger
+    attr_accessor :entries, :renderers, :interactive, :validators
+    def initialize(header, options = {})
+      @header = header
+      @interactive = options.fetch(:interactive, true)
+      @entries = options.fetch(:entries, [])
+      @description = options.fetch(:description, '')
+      @renderers = options.fetch(:renderers, self.class.default_renderers)
+      @validators = options.fetch(:validators, [])
+      @validators << lambda { |values| check_required_entries(values) }
+      @logger = options.fetch(:logger) do |l|
+        logger = Logger.new(STDERR)
+        logger.level = Logger::ERROR
+        logger
+      end
+    end
+
+    def run
+      if @interactive
+        choice = execute_menu
+      else
+        choice = nil
+        default_button = buttons.find { |b| b.default? }
+        choice = default_button.name if default_button
+      end
+      choice
+    end
+
+    def execute_menu
+    end
+
+    def buttons
+      @entries.select { |e| e.class >= KafoWizards::Entries::ButtonEntry }
+    end
+
+    def triggers
+      buttons.inject([]) do |b_names, b|
+        b_names << b.name if b.trigger_validation?
+        b_names
+      end
+    end
+
+    def values
+      @entries.inject({}) do |vals, entry|
+        vals[entry.name] = entry.value unless entry.class >= KafoWizards::Entries::ButtonEntry
+        vals
+      end
+    end
+
+    def update(values = {})
+
+      entries.each do |entry|
+        entry.update(values[entry.name]) unless values[entry.name].nil?
+      end
+    end
+
+    def validate(values)
+      errors = []
+      validated = @validators.inject(values) do |result, lam|
+        begin
+          lam.call(result)
+        rescue ValidationError => e
+          errors += e.messages
+          result
+        end
+      end
+      raise ValidationError.new errors unless errors.empty?
+      validated
+    end
+
+    def factory
+      Factory.new(self)
+    end
+
+    def self.default_renderers
+      @default_renderers ||= {}
+    end
+
+    def self.register_default_renderer(display_type, renderer)
+      default_renderers[display_type] = renderer
+    end
+
+    protected
+
+    def check_required_entries(values)
+      messages = entries.inject([]) do |messages, e|
+        messages << "#{e.label} must be present" if e.required? && values[e.name].nil?
+        messages
+      end
+      raise ValidationError.new(messages) unless messages.empty?
+      values
+    end
+
+    def call_renderer_for_entry(render_method, entry)
+      display_type = entry.display_type(true).find { |dt| @renderers.has_key?(dt) && @renderers[dt].respond_to?(render_method) }
+      @renderers[display_type].send(render_method, entry) if display_type
+    end
+
+  end
+end

data/lib/kafo_wizards/entries.rb

@@ -0,0 +1,9 @@
+require 'kafo_wizards/entries/abstract'
+require 'kafo_wizards/entries/string'
+require 'kafo_wizards/entries/string_or_file'
+require 'kafo_wizards/entries/button'
+require 'kafo_wizards/entries/password'
+require 'kafo_wizards/entries/boolean'
+require 'kafo_wizards/entries/ip_address'
+require 'kafo_wizards/entries/netmask'
+require 'kafo_wizards/entries/selector'

data/lib/kafo_wizards/entries/abstract.rb

@@ -0,0 +1,72 @@
+module KafoWizards::Entries
+  class AbstractEntry
+    attr_reader :name, :default_value, :value, :label
+    attr_accessor :description, :validators, :parent, :post_hook, :pre_hook
+
+    def initialize(name, options={})
+      @name = name
+      @value = @default_value = options.fetch(:default_value, nil)
+      @label = options.fetch(:label, @name.to_s.gsub('_', ' ').capitalize)
+      @description = options.fetch(:description, '')
+      @validators = options.fetch(:validators, [])
+      @required = !!options.fetch(:required, false)
+      @parent = options.fetch(:parent, nil)
+      @post_hook = options.fetch(:post_hook, nil)
+      @pre_hook = options.fetch(:pre_hook, nil)
+    end
+
+    def display_type(with_ancestry=false)
+      classes = self.class.ancestors.select { |cls| cls.name =~ /Entry\Z/ }
+      if with_ancestry
+        result = classes.map { |cls| class_to_underscore(cls.name) }
+      else
+        result = class_to_underscore(classes.first.name)
+      end
+    end
+
+    def required?
+      @required
+    end
+
+    def call_post_hook
+      post_hook.call(self) if post_hook
+    end
+
+    def call_pre_hook
+      pre_hook.call(self) if pre_hook
+    end
+
+    def update(new_value)
+      value = validate(new_value)
+      @value = @validators.inject(value) { |result, lam| lam.call(result) }
+      @value
+    end
+
+    def validate(new_value)
+      new_value
+    end
+
+    def self.descendants
+      @descendants ||= []
+    end
+
+    def self.inherited(child)
+      superclass.inherited(child) if self < KafoWizards::Entries::AbstractEntry
+      descendants << child
+    end
+
+    def self.entry_type
+      :abstract
+    end
+
+    protected
+
+    def class_to_underscore(class_name)
+      class_name.split('::').last.gsub(/Entry/, '').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase.to_sym
+    end
+  end
+end

data/lib/kafo_wizards/entries/boolean.rb

@@ -0,0 +1,15 @@
+module KafoWizards::Entries
+
+  class BooleanEntry < AbstractEntry
+
+    def initialize(name, options={})
+      super(name, options)
+      @value = @default_value ? true : false
+    end
+
+    def self.entry_type
+      :boolean
+    end
+
+  end
+end

data/lib/kafo_wizards/entries/button.rb

@@ -0,0 +1,27 @@
+module KafoWizards::Entries
+
+  class ButtonEntry < AbstractEntry
+
+    attr_reader :name
+
+    def initialize(name, options={})
+      super(name, options)
+      @default = !!options.fetch(:default, true)
+      @value = name
+      @trigger_validation = !!options.fetch(:trigger_validation, true)
+    end
+
+    def default?
+      @default
+    end
+
+    def trigger_validation?
+      @trigger_validation
+    end
+
+    def self.entry_type
+      :button
+    end
+
+  end
+end

data/lib/kafo_wizards/entries/ip_address.rb

@@ -0,0 +1,16 @@
+module KafoWizards::Entries
+
+  class IPAddressEntry < StringEntry
+    def validate(value)
+      if !(value =~ Resolv::IPv4::Regex)
+        raise KafoWizards::ValidationError.new("#{value} is not valid IP address")
+      end
+      value
+    end
+
+    def self.entry_type
+      :ip_address
+    end
+
+  end
+end

data/lib/kafo_wizards/entries/netmask.rb

@@ -0,0 +1,25 @@
+require 'ipaddr'
+module KafoWizards::Entries
+
+  class NetmaskEntry < IPAddressEntry
+    def validate(value)
+      if value.to_s.include?('/')
+        begin
+          mask_len = value.split('/').last.to_i
+          value = IPAddr.new('255.255.255.255').mask(mask_len).to_s
+        rescue IPAddr::InvalidPrefixError => e
+          raise KafoWizards::ValidationError.new("#{value} is not valid netmask (#{e.message})")
+        end
+      end
+      if !(value =~ Resolv::IPv4::Regex)
+        raise KafoWizards::ValidationError.new("#{value} is not valid netmask")
+      end
+      value
+    end
+
+    def self.entry_type
+      :netmask
+    end
+
+  end
+end

data/lib/kafo_wizards/entries/password.rb

@@ -0,0 +1,33 @@
+module KafoWizards::Entries
+
+  class PasswordEntry < StringEntry
+
+    def initialize(name, options={})
+      super(name, options)
+      @confirmation_required = !!options.fetch(:confirmation_required, false)
+    end
+
+    def confirmation_required?
+      @confirmation_required
+    end
+
+    def validate(value)
+      if value.length < 8
+        raise KafoWizards::ValidationError.new("Password must be at least 8 characters long")
+      end
+      value
+    end
+
+    def update(value)
+      if confirmation_required? && (value[:password] != value[:password_confirmation])
+        raise KafoWizards::ValidationError.new("Password and confirmation do not match")
+      end
+      @value = validate(value[:password])
+    end
+
+    def self.entry_type
+      :password
+    end
+
+  end
+end

data/lib/kafo_wizards/entries/selector.rb

@@ -0,0 +1,22 @@
+module KafoWizards::Entries
+
+  class SelectorEntry < StringEntry
+    attr_accessor :options
+
+    def initialize(name, options={})
+      super(name, options)
+      @options = options.fetch(:options, {})
+    end
+
+    def validate(value)
+      raise KafoWizards::ValidationError.new("#{value} is not a valid option") unless options.include?(value)
+      value
+    end
+
+    def self.entry_type
+      :selector
+    end
+
+  end
+
+end

data/lib/kafo_wizards/entries/string.rb

@@ -0,0 +1,12 @@
+module KafoWizards::Entries
+  class StringEntry < AbstractEntry
+    def initialize(name, options={})
+      super(name, options)
+    end
+
+    def self.entry_type
+      :string
+    end
+
+  end
+end

data/lib/kafo_wizards/entries/string_or_file.rb

@@ -0,0 +1,14 @@
+module KafoWizards::Entries
+
+  class StringOrFileEntry < StringEntry
+
+    def initialize(name, options={})
+      super(name, options)
+    end
+
+    def self.entry_type
+      :string_or_file
+    end
+
+  end
+end

data/lib/kafo_wizards/exceptions.rb

@@ -0,0 +1,12 @@
+module KafoWizards
+
+    class ValidationError < StandardError
+      attr_reader :messages
+
+      def initialize(msg=nil)
+        messages = [msg].flatten(1)
+        super(messages.join("; "))
+        @messages = messages
+      end
+    end
+end

data/lib/kafo_wizards/factory.rb

@@ -0,0 +1,24 @@
+module KafoWizards
+
+  def self.wizard(kind, header, options={})
+    HighLine::Wizard.new(header, options)
+  end
+
+  class Factory
+
+    def initialize(wizard=nil)
+      @wizard = wizard
+    end
+
+    def method_missing(meth, *args, &block)
+      if @wizard
+        args << {} unless args.last.class <= Hash
+        args[-1][:parent] = @wizard unless args[-1].has_key?(:parent)
+      end
+
+      entry_cls = KafoWizards::Entries::AbstractEntry.descendants.find { |ec| ec.entry_type == meth }
+      raise NameError.new "Unknown type of entry (#{meth.to_s})" unless entry_cls
+      entry_cls.new(*args)
+    end
+  end
+end

data/lib/kafo_wizards/highline.rb

@@ -0,0 +1,8 @@
+require 'kafo_wizards/highline/wizard'
+require 'kafo_wizards/highline/abstract_renderer'
+require 'kafo_wizards/highline/boolean_renderer'
+require 'kafo_wizards/highline/button_renderer'
+require 'kafo_wizards/highline/string_renderer'
+require 'kafo_wizards/highline/password_renderer'
+require 'kafo_wizards/highline/string_or_file_renderer'
+require 'kafo_wizards/highline/selector_renderer'

data/lib/kafo_wizards/highline/abstract_renderer.rb

@@ -0,0 +1,17 @@
+module KafoWizards
+  module HighLine
+    class AbstractRenderer
+      def render_value(entry)
+      end
+
+      def render_entry(entry)
+      end
+
+      def render_action(entry)
+      end
+    end
+
+    # register renderer to the highline wizard
+    Wizard.register_default_renderer :abstract, KafoWizards::HighLine::AbstractRenderer.new
+  end
+end

data/lib/kafo_wizards/highline/boolean_renderer.rb

@@ -0,0 +1,21 @@
+module KafoWizards
+  module HighLine
+    class BooleanRenderer < AbstractRenderer
+      def render_value(entry)
+        entry.value ? "#{::HighLine.color("Yes", :green)}" : "#{::HighLine.color("No", :red)}"
+      end
+
+      def render_entry(entry)
+        "Toggle #{entry.label}"
+      end
+
+      def render_action(entry)
+        entry.update(!entry.value)
+        nil
+      end
+    end
+
+    # register renderer to the highline wizard
+    Wizard.register_default_renderer :boolean, KafoWizards::HighLine::BooleanRenderer.new
+  end
+end

data/lib/kafo_wizards/highline/button_renderer.rb

@@ -0,0 +1,17 @@
+module KafoWizards
+  module HighLine
+    class ButtonRenderer < AbstractRenderer
+      def render_entry(entry)
+        color = entry.default? ? :green : :red
+        "#{::HighLine.color(entry.label, color)}"
+      end
+
+      def render_action(entry)
+        entry.name
+      end
+    end
+
+    # register renderer to the highline wizard
+    Wizard.register_default_renderer :button, KafoWizards::HighLine::ButtonRenderer.new
+  end
+end

data/lib/kafo_wizards/highline/password_renderer.rb

@@ -0,0 +1,24 @@
+module KafoWizards
+  module HighLine
+
+    class PasswordRenderer < StringRenderer
+      def render_value(entry)
+        "#{::HighLine.color("**********", :blue)}"
+      end
+
+      def render_action(entry)
+        password = ask("Enter new password: ") { |q| q.echo = "*" }
+        if !entry.confirmation_required?
+          entry.update(:password => password)
+        else
+          password_confirmation = ask("Re-type new password: ") { |q| q.echo = "*" }
+          entry.update(:password => password, :password_confirmation => password_confirmation)
+        end
+        nil
+      end
+    end
+
+    # register renderer to the highline wizard
+    Wizard.register_default_renderer :password, KafoWizards::HighLine::PasswordRenderer.new
+  end
+end

data/lib/kafo_wizards/highline/selector_renderer.rb

@@ -0,0 +1,32 @@
+module KafoWizards
+  module HighLine
+
+    class SelectorRenderer < StringRenderer
+      def render_value(entry)
+        value = entry.options[entry.value].to_s
+        "'#{::HighLine.color(value, :blue)}'"
+      end
+
+      def render_entry(entry)
+        "Select #{entry.label}"
+      end
+
+      def render_action(entry)
+        choose do |sel|
+          sel.header = ::HighLine.color("Available options", :white)
+          sel.prompt = "Select #{entry.label}: "
+          sel.select_by = :index
+          entry.options.each_pair do |opt, label|
+            sel.choice(label) do
+              entry.update(opt)
+              nil
+            end
+          end
+        end
+      end
+    end
+
+    # register renderer to the highline wizard
+    Wizard.register_default_renderer :selector, KafoWizards::HighLine::SelectorRenderer.new
+  end
+end

data/lib/kafo_wizards/highline/string_or_file_renderer.rb

@@ -0,0 +1,25 @@
+module KafoWizards
+  module HighLine
+
+    class StringOrFileRenderer < StringRenderer
+      def render_value(entry)
+        value = entry.value.to_s
+        if value.length > 40
+          value = entry.value[0..37]+'...'
+        end
+        "'#{::HighLine.color(value, :blue)}' (#{entry.value.to_s.length} bytes)"
+      end
+
+      def render_action(entry)
+        say entry.description if entry.description
+        key = ask("file path or key")
+        key = File.read(key) if File.exists?(key)
+        entry.update(key.chomp)
+        nil
+      end
+    end
+
+    # register renderer to the highline wizard
+    Wizard.register_default_renderer :string_or_file, KafoWizards::HighLine::StringOrFileRenderer.new
+  end
+end

data/lib/kafo_wizards/highline/string_renderer.rb

@@ -0,0 +1,23 @@
+module KafoWizards
+  module HighLine
+    class StringRenderer < AbstractRenderer
+
+      def render_value(entry)
+        "'#{::HighLine.color(entry.value.to_s, :blue)}'"
+      end
+
+      def render_entry(entry)
+        "Change #{entry.label}"
+      end
+
+      def render_action(entry)
+        say entry.description if entry.description
+        key = ask("New value for #{entry.label}: ")
+        entry.update(key.chomp)
+        nil
+      end
+    end
+    # register renderer to the highline wizard
+    Wizard.register_default_renderer :string, KafoWizards::HighLine::StringRenderer.new
+  end
+end

data/lib/kafo_wizards/highline/wizard.rb

@@ -0,0 +1,99 @@
+require 'highline/import'
+
+module KafoWizards
+  module HighLine
+    class Wizard < AbstractWizard
+
+      def execute_menu
+        begin
+          choice = nil
+          loop do
+            say "\n"
+            say ::HighLine.color(header, :yellow) unless header.empty?
+            print_values
+            say "\n" + description
+            choice = print_menu
+            break unless choice.nil?
+          end
+          validate(values) if triggers.include? choice
+          choice
+        rescue KafoWizards::ValidationError => e
+          say ::HighLine.color("\nUnable to procedd due to following error(s):", :red)
+          say ::HighLine.color(format_errors(e.messages), :red)
+          say "\n"
+          retry
+        end
+      end
+
+      def print_values
+        entries.each do |entry|
+          max_label_width = 25
+          next if (entry.class <= KafoWizards::Entries::ButtonEntry)
+          if entry.required?
+            label = ::HighLine.color(('*'+entry.label).rjust(max_label_width), :bold, :yellow)
+          else
+            label = entry.label.rjust(max_label_width)
+          end
+          say "#{label}: " + render_value(entry)
+        end
+      end
+
+      def print_menu
+        choose do |menu|
+          menu.header = ::HighLine.color("\nAvailable actions", :white)
+          menu.prompt = 'Your choice: '
+          menu.select_by = :index
+
+          sorted_entries.each do |entry|
+            menu.choice(render_entry(entry)) do
+              begin
+                entry.call_pre_hook
+                res = render_action(entry)
+                entry.call_post_hook
+                res
+              rescue KafoWizards::ValidationError => e
+                say ::HighLine.color("\nValidation error: #{e.message}", :red)
+                say "Please, try again... \n\n"
+                retry
+              rescue Interrupt
+                nil
+              end
+            end
+          end
+        end
+      end
+
+
+      def render_action(entry)
+        call_renderer_for_entry(:render_action, entry)
+      end
+
+      def render_value(entry)
+        call_renderer_for_entry(:render_value, entry)
+      end
+
+      def render_entry(entry)
+        call_renderer_for_entry(:render_entry, entry)
+      end
+
+      protected
+      def sorted_entries
+        sorted = { :default => [], :entries => [], :buttons => []}
+        sorted = entries.inject(sorted) do |res, entry|
+          if entry.class <= KafoWizards::Entries::ButtonEntry
+            cat = entry.default? ? :default : :buttons
+          else
+            cat = :entries
+          end
+          res[cat] << entry
+          res
+        end
+        sorted[:default] + sorted[:entries] + sorted[:buttons]
+      end
+
+      def format_errors(errors)
+        errors.map{ |e| "- #{e}"}.join("\n")
+      end
+    end
+  end
+end

data/lib/kafo_wizards/version.rb

@@ -0,0 +1,3 @@
+module KafoWizards
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,184 @@
+--- !ruby/object:Gem::Specification
+name: kafo_wizards
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Martin Bačovský
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ci_reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem helps to create wizard like interfaces in terminal applications,
+  has support for nesting and value validation
+email:
+- mbacovsk@redhat.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/kafo_wizards.rb
+- lib/kafo_wizards/abstract_wizard.rb
+- lib/kafo_wizards/entries.rb
+- lib/kafo_wizards/entries/abstract.rb
+- lib/kafo_wizards/entries/boolean.rb
+- lib/kafo_wizards/entries/button.rb
+- lib/kafo_wizards/entries/ip_address.rb
+- lib/kafo_wizards/entries/netmask.rb
+- lib/kafo_wizards/entries/password.rb
+- lib/kafo_wizards/entries/selector.rb
+- lib/kafo_wizards/entries/string.rb
+- lib/kafo_wizards/entries/string_or_file.rb
+- lib/kafo_wizards/exceptions.rb
+- lib/kafo_wizards/factory.rb
+- lib/kafo_wizards/highline.rb
+- lib/kafo_wizards/highline/abstract_renderer.rb
+- lib/kafo_wizards/highline/boolean_renderer.rb
+- lib/kafo_wizards/highline/button_renderer.rb
+- lib/kafo_wizards/highline/password_renderer.rb
+- lib/kafo_wizards/highline/selector_renderer.rb
+- lib/kafo_wizards/highline/string_or_file_renderer.rb
+- lib/kafo_wizards/highline/string_renderer.rb
+- lib/kafo_wizards/highline/wizard.rb
+- lib/kafo_wizards/version.rb
+homepage: https://github.com/theforeman/kafo_wizards
+licenses:
+- GPLv3+
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.4
+signing_key: 
+specification_version: 4
+summary: Wizard like interfaces in terminal
+test_files: []