bolt 0.21.2 → 0.21.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19cf0dd944021e5b7255b245987961c4155b4ea9400e5d65ad384342fa094a0d
-  data.tar.gz: 3755fd0a3e63d7e28e82b08e255953c51b0b539ceb3e180a69930a6cdddc1eb2
+  metadata.gz: bfc1d47b6d45382d603a222c1aa4a5066a560e4439799afc00a15b44002497fb
+  data.tar.gz: 9e1c7c4c69d255092849484da518a6c9c02115917f8f5f3475ee8669b322bf70
 SHA512:
-  metadata.gz: 84db88c85867ef1a27f4a726f2672ba1b78d453cec47f0f003326079c777b398039f5516e2c1f33697e7ac19e9d861b75d4767cb9512bf7e9bb8dbabe2ad19a1
-  data.tar.gz: 0b465783458691bbcb78f1f52eba1b4e7b04c2840e1c06ea24f6ddf4947d6daf5d664b21d4d77062d88eaeace4f224edb5bb1dfada97131fd0e1356d330b9846
+  metadata.gz: 29dd0f53e14ef2d7787e59ddf121f3a96a27c7b0810b3971a55a377c2e0f5d0996f78359e685459edbafea7a78e2e284b454027e22906edde2790bc9452ed23b
+  data.tar.gz: cb7268a4c9de0d2b8fd99649d112276c8542275b8f3ce7e134f7b1b2a041cb688537e13ce98a607753c597eec028ff1fb29c09ad1b18ead6aa291014e4dfb91d

data/bolt-modules/boltlib/lib/puppet/functions/puppetdb_fact.rb

@@ -17,14 +17,8 @@ Puppet::Functions.create_function(:puppetdb_fact) do
   end
 
   def puppetdb_fact(certnames)
-    unless Puppet[:tasks]
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'puppetdb_fact'
-      )
-    end
-
     puppetdb_client = Puppet.lookup(:bolt_pdb_client) { nil }
-    unless puppetdb_client && Puppet.features.bolt?
+    unless puppetdb_client
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
         Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('query facts from puppetdb')
       )

data/bolt-modules/boltlib/lib/puppet/functions/puppetdb_query.rb

@@ -16,7 +16,7 @@ Puppet::Functions.create_function(:puppetdb_query) do
 
   def make_query(query)
     puppetdb_client = Puppet.lookup(:bolt_pdb_client) { nil }
-    unless Puppet[:tasks] && puppetdb_client && Puppet.features.bolt?
+    unless puppetdb_client
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
         Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('query facts from puppetdb')
       )

data/bolt-modules/boltlib/lib/puppet/functions/run_plan.rb

@@ -13,6 +13,7 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
     scope_param
     param 'String', :plan_name
     optional_param 'Hash', :named_args
+    return_type 'Boltlib::PlanResult'
   end
 
   def run_plan(scope, plan_name, named_args = {})
@@ -35,6 +36,9 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
       executor.report_function_call('run_plan')
     end
 
+    # Report bundled content, this should capture plans run from both CLI and Plans
+    executor.report_bundled_content('Plan', plan_name)
+
     params = named_args.reject { |k, _| k.start_with?('_') }
 
     loaders = closure_scope.compiler.loaders

data/bolt-modules/boltlib/lib/puppet/functions/run_task.rb

@@ -86,6 +86,9 @@ Puppet::Functions.create_function(:run_task) do
       executor.report_function_call('run_task')
     end
 
+    # Report bundled content, this should capture tasks run from both CLI and Plans
+    executor.report_bundled_content('Task', task_name)
+
     # Ensure that given targets are all Target instances
     targets = inventory.get_targets(targets)
 

data/bolt-modules/boltlib/types/planresult.pp

@@ -1,4 +1,4 @@
-# A Planresult describes the supported return values of a plan. It
+# A PlanResult describes the supported return values of a plan. It
 # should be used as the return type of functions that run plans and return the
 # results.
 

data/lib/bolt/analytics.rb

@@ -24,7 +24,6 @@ module Bolt
 
     def self.build_client
       logger = Logging.logger[self]
-
       config_file = File.expand_path('~/.puppetlabs/bolt/analytics.yaml')
       config = load_config(config_file)
 

data/lib/bolt/applicator.rb

@@ -2,17 +2,72 @@
 
 require 'json'
 require 'open3'
+require 'concurrent'
 
 module Bolt
   Task = Struct.new(:name, :implementations, :input_method)
 
   class Applicator
-    def initialize(inventory, executor)
+    def initialize(inventory, executor, modulepath, pdb_config, hiera_config, max_compiles)
       @inventory = inventory
       @executor = executor
+      @modulepath = modulepath
+      @pdb_config = pdb_config
+      @hiera_config = hiera_config ? validate_hiera_config(hiera_config) : nil
+
+      @pool = Concurrent::ThreadPoolExecutor.new(max_threads: max_compiles)
+    end
+
+    private def libexec
+      @libexec ||= File.join(Gem::Specification.find_by_name('bolt').gem_dir, 'libexec')
+    end
+
+    def catalog_apply_task
+      @catalog_apply_task ||= begin
+        path = File.join(libexec, 'apply_catalog.rb')
+        impl = { 'name' => 'apply_catalog.rb', 'path' => path, 'requirements' => [], 'supports_noop' => true }
+        Task.new('apply_catalog', [impl], 'stdin')
+      end
+    end
+
+    def compile(target, ast, plan_vars)
+      trusted = Puppet::Context::TrustedInformation.new('local', target.host, {})
+
+      catalog_input = {
+        code_ast: ast,
+        modulepath: @modulepath,
+        pdb_config: @pdb_config,
+        hiera_config: @hiera_config,
+        target: {
+          name: target.host,
+          facts: @inventory.facts(target),
+          variables: @inventory.vars(target).merge(plan_vars),
+          trusted: trusted.to_h
+        }
+      }
+
+      bolt_catalog_exe = File.join(libexec, 'bolt_catalog')
+
+      old_path = ENV['PATH']
+      ENV['PATH'] = "#{RbConfig::CONFIG['bindir']}#{File::PATH_SEPARATOR}#{old_path}"
+      out, err, stat = Open3.capture3('ruby', bolt_catalog_exe, 'compile', stdin_data: catalog_input.to_json)
+      ENV['PATH'] = old_path
+
+      raise ApplyError.new(target.to_s, err) unless stat.success?
+      JSON.parse(out)
     end
 
-    def apply(args, apply_body, _scope)
+    def validate_hiera_config(hiera_config)
+      if File.exist?(File.path(hiera_config))
+        data = File.open(File.path(hiera_config), "r:UTF-8") { |f| YAML.safe_load(f.read) }
+        unless data['version'] == 5
+          raise ApplyError.new("All Targets", "Hiera v5 is required.")
+        end
+        hiera_config
+      end
+    end
+
+    def apply(args, apply_body, scope)
       raise(ArgumentError, 'apply requires a TargetSpec') if args.empty?
       type0 = Puppet.lookup(:pal_script_compiler).type('TargetSpec')
       Puppet::Pal.assert_type(type0, args[0], 'apply targets')
@@ -24,33 +79,36 @@ module Bolt
         params = args[1]
       end
 
+      # collect plan vars and merge them over target vars
+      plan_vars = scope.to_hash
+      %w[trusted server_facts facts].each { |k| plan_vars.delete(k) }
+
       targets = @inventory.get_targets(args[0])
       ast = Puppet::Pops::Serialization::ToDataConverter.convert(apply_body, rich_data: true, symbol_to_string: true)
-      results = targets.map do |target|
-        catalog_input = {
-          code_ast: ast,
-          modulepath: [],
-          target: {
-            name: target.host,
-            facts: @inventory.facts(target),
-            variables: @inventory.vars(target)
-          }
-        }
+      notify = proc { |_| nil }
 
-        libexec = File.join(Gem::Specification.find_by_name('bolt').gem_dir, 'libexec')
+      @executor.log_action('apply catalog', targets) do
+        futures = targets.map do |target|
+          Concurrent::Future.execute(executor: @pool) do
+            @executor.with_node_logging("Compiling manifest block", [target]) do
+              compile(target, ast, plan_vars)
+            end
+          end
+        end
 
-        bolt_catalog_exe = File.join(libexec, 'bolt_catalog')
-        out, err, stat = Open3.capture3(bolt_catalog_exe, 'compile', stdin_data: catalog_input.to_json)
-        raise ApplyError.new(target.to_s, err) unless stat.success?
-        catalog = JSON.parse(out)
+        result_promises = targets.zip(futures).flat_map do |target, future|
+          @executor.queue_execute([target]) do |transport, batch|
+            @executor.with_node_logging("Applying manifest block", batch) do
+              arguments = params.clone
+              arguments['catalog'] = future.value
+              raise future.reason if future.rejected?
+              transport.batch_task(batch, catalog_apply_task, arguments, {}, &notify)
+            end
+          end
+        end
 
-        path = File.join(libexec, 'apply_catalog.rb')
-        impl = { 'name' => 'apply_catalog.rb', 'path' => path, 'requirements' => [], 'supports_noop' => true }
-        task = Task.new('apply_catalog', [impl], 'stdin')
-        params['catalog'] = catalog
-        @executor.run_task([target], task, params, '_description' => 'apply catalog')
+        @executor.await_results(result_promises)
       end
-      ResultSet.new results.reduce([]) { |result, result_set| result + result_set.results }
     end
   end
 end

data/lib/bolt/bolt_option_parser.rb

@@ -183,6 +183,10 @@ Available options are:
              'Maximum number of simultaneous connections (default: 100)') do |concurrency|
         @options[:concurrency] = concurrency
       end
+      define('--compile-concurrency CONCURRENCY', Integer,
+             'Maximum number of simultaneous manifest block compiles (default: number of cores)') do |concurrency|
+        @options[:'compile-concurrency'] = concurrency
+      end
       define('--modulepath MODULES',
              "List of directories containing modules, separated by '#{File::PATH_SEPARATOR}'") do |modulepath|
         @options[:modulepath] = modulepath.split(File::PATH_SEPARATOR)

data/lib/bolt/catalog.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'bolt/pal'
+require 'bolt/puppetdb'
+require 'bolt/util/on_access'
 
 Bolt::PAL.load_puppet
 
@@ -53,13 +55,7 @@ end
 
 module Bolt
   class Catalog
-    def in_env
-      Puppet::Pal.in_tmp_environment('bolt_apply', modulepath: ['~/bolt/modules/'], facts: @scope['facts']) do |pal|
-        yield pal
-      end
-    end
-
-    def with_puppet_settings
+    def with_puppet_settings(hiera_config)
       Dir.mktmpdir('bolt') do |dir|
         cli = []
         Puppet::Settings::REQUIRED_APP_SETTINGS.each do |setting|
@@ -67,20 +63,19 @@ module Bolt
         end
         Puppet.settings.send(:clear_everything_for_tests)
         Puppet.initialize_settings(cli)
+        Puppet.settings[:hiera_config] = hiera_config
         # self.class.configure_logging
         yield
       end
     end
 
-    def setup_node(node)
+    def setup_node(node, trusted)
       facts = Puppet.lookup(:pal_facts)
       node_facts = Puppet::Node::Facts.new(Puppet[:node_name_value], facts)
       node.fact_merge(node_facts)
 
       node.parameters = node.parameters.merge(Puppet.lookup(:pal_variables))
-      # TODO: setup server_facts
-      # TODO: setup trusted in params
-      # TODO: setup serverversion/clientversion in params
+      node.trusted_data = trusted
     end
 
     def compile_node(node)
@@ -101,7 +96,13 @@ module Bolt
     def compile_catalog(request)
       pal_main = request['code_ast'] || request['code_string']
       target = request['target']
-      with_puppet_settings do
+
+      pdb_client = Bolt::Util::OnAccess.new do
+        pdb_config = Bolt::PuppetDB::Config.new(nil, request['pdb_config'])
+        Bolt::PuppetDB::Client.from_config(pdb_config)
+      end
+
+      with_puppet_settings(request['hiera_config']) do
         Puppet[:code] = ''
         Puppet[:node_name_value] = target['name']
         Puppet::Pal.in_tmp_environment(
@@ -111,9 +112,9 @@ module Bolt
           variables: target["variables"] || {}
         ) do |_pal|
           node = Puppet.lookup(:pal_current_node)
-          setup_node(node)
+          setup_node(node, target["trusted"])
 
-          Puppet.override(pal_main: pal_main) do
+          Puppet.override(pal_main: pal_main, bolt_pdb_client: pdb_client) do
             compile_node(node)
           end
         end

data/lib/bolt/cli.rb

@@ -262,7 +262,7 @@ module Bolt
                          params: params }
         plan_context[:description] = options[:description] if options[:description]
 
-        executor = Bolt::Executor.new(config, @analytics, options[:noop])
+        executor = Bolt::Executor.new(config, @analytics, options[:noop], bundled_content: bundled_content)
         executor.start_plan(plan_context)
         result = pal.run_plan(options[:object], options[:task_options], executor, inventory, puppetdb_client)
 
@@ -271,7 +271,7 @@ module Bolt
         outputter.print_plan_result(result)
         code = result.ok? ? 0 : 1
       else
-        executor = Bolt::Executor.new(config, @analytics, options[:noop])
+        executor = Bolt::Executor.new(config, @analytics, options[:noop], bundled_content: bundled_content)
         targets = options[:targets]
 
         results = nil
@@ -353,5 +353,16 @@ module Bolt
     def outputter
       @outputter ||= Bolt::Outputter.for_format(config[:format], config[:color], config[:trace])
     end
+
+    def bundled_content
+      default_content = Bolt::PAL.new(Bolt::Config.new)
+      plans = default_content.list_plans.each_with_object([]) do |iter, col|
+        col << iter&.first
+      end
+      tasks = default_content.list_tasks.each_with_object([]) do |iter, col|
+        col << iter&.first
+      end
+      plans.concat tasks
+    end
   end
 end

data/lib/bolt/config.rb

@@ -2,6 +2,7 @@
 
 require 'yaml'
 require 'logging'
+require 'concurrent'
 require 'bolt/cli'
 require 'bolt/transport/ssh'
 require 'bolt/transport/winrm'
@@ -25,12 +26,14 @@ module Bolt
 
   Config = Struct.new(
     :concurrency,
+    :'compile-concurrency',
     :format,
     :trace,
     :inventoryfile,
     :log,
     :modulepath,
     :puppetdb,
+    :'hiera-config',
     :color,
     :transport,
     :transports
@@ -38,6 +41,7 @@ module Bolt
 
     DEFAULTS = {
       concurrency: 100,
+      'compile-concurrency': Concurrent.processor_count,
       transport: 'ssh',
       format: 'human',
       modulepath: [],
@@ -131,7 +135,7 @@ module Bolt
         self[:modulepath] = data['modulepath'].split(File::PATH_SEPARATOR)
       end
 
-      %w[inventoryfile concurrency format puppetdb color transport].each do |key|
+      %w[inventoryfile concurrency compile-concurrency format puppetdb hiera-config color transport].each do |key|
         if data.key?(key)
           self[key.to_sym] = data[key]
         end
@@ -197,8 +201,12 @@ module Bolt
       File.join(boltdir, 'inventory.yaml')
     end
 
+    def default_hiera
+      File.join(boltdir, 'hiera.yaml')
+    end
+
     def update_from_cli(options)
-      %i[concurrency transport format trace modulepath inventoryfile color].each do |key|
+      %i[concurrency compile-concurrency transport format trace modulepath inventoryfile color].each do |key|
         self[key] = options[key] if options.key?(key)
       end
 
@@ -236,6 +244,7 @@ module Bolt
     # 'inventoryfile' cannot be included here or they will not be handled correctly.
     def update_from_defaults
       self[:modulepath] = default_modulepath
+      self[:'hiera-config'] = default_hiera
     end
 
     # The order in which config is processed is important
@@ -248,6 +257,7 @@ module Bolt
     def load_file(path)
       data = Bolt::Util.read_config_file(path, [default_config], 'config')
       update_from_file(data) if data
+      validate_hiera_conf(data ? data['hiera-config'] : nil)
     end
 
     def update_from_inventory(data)
@@ -263,6 +273,10 @@ module Bolt
         transports: self[:transports] }
     end
 
+    def validate_hiera_conf(path)
+      Bolt::Util.read_config_file(path, [default_hiera], 'hiera-config')
+    end
+
     def validate
       self[:log].each_pair do |name, params|
         if params.key?(:level) && !Bolt::Logger.valid_level?(params[:level])
@@ -274,6 +288,19 @@ module Bolt
         end
       end
 
+      unless self[:concurrency].is_a?(Integer) && self[:concurrency] > 0
+        raise Bolt::ValidationError, 'Concurrency must be a positive integer'
+      end
+
+      unless self[:'compile-concurrency'].is_a?(Integer) && self[:'compile-concurrency'] > 0
+        raise Bolt::ValidationError, 'Compile concurrency must be a positive integer'
+      end
+
+      compile_limit = 2 * Concurrent.processor_count
+      unless self[:'compile-concurrency'] < compile_limit
+        raise Bolt::ValidationError, "Compilation is CPU-intensive, set concurrency less than #{compile_limit}"
+      end
+
       unless %w[human json].include? self[:format]
         raise Bolt::ValidationError, "Unsupported format: '#{self[:format]}'"
       end

data/lib/bolt/error.rb

@@ -94,7 +94,7 @@ module Bolt
 
   class ValidationError < Bolt::Error
     def initialize(msg)
-      super(msg, 'bolt.transport/validation-error')
+      super(msg, 'bolt/validation-error')
     end
   end
 

data/lib/bolt/executor.rb

@@ -18,9 +18,13 @@ module Bolt
     attr_reader :noop, :transports
     attr_accessor :run_as, :plan_logging
 
-    def initialize(config = Bolt::Config.new, analytics = Bolt::Analytics::NoopClient.new, noop = nil)
+    def initialize(config = Bolt::Config.new,
+                   analytics = Bolt::Analytics::NoopClient.new,
+                   noop = nil,
+                   bundled_content: nil)
       @config = config
       @analytics = analytics
+      @bundled_content = bundled_content
       @logger = Logging.logger[self]
       @plan_logging = false
 
@@ -46,15 +50,14 @@ module Bolt
       impl.value
     end
 
-    # Execute the given block on a list of nodes in parallel, one thread per "batch".
+    # Starts executing the given block on a list of nodes in parallel, one thread per "batch".
     #
     # This is the main driver of execution on a list of targets. It first
     # groups targets by transport, then divides each group into batches as
-    # defined by the transport. Each batch, along with the corresponding
-    # transport, is yielded to the block in turn and the results all collected
-    # into a single ResultSet.
-    def batch_execute(targets)
-      promises = targets.group_by(&:protocol).flat_map do |protocol, protocol_targets|
+    # defined by the transport. Yields each batch, along with the corresponding
+    # transport, to the block in turn and returns an array of result promises.
+    def queue_execute(targets)
+      targets.group_by(&:protocol).flat_map do |protocol, protocol_targets|
         transport = transport(protocol)
         report_transport(transport, protocol_targets.count)
         transport.batches(protocol_targets).flat_map do |batch|
@@ -90,9 +93,25 @@ module Bolt
           batch_promises.values
         end
       end
+    end
+
+    # Create a ResultSet from the results of all promises.
+    def await_results(promises)
       ResultSet.new(promises.map(&:value))
     end
 
+    # Execute the given block on a list of nodes in parallel, one thread per "batch".
+    #
+    # This is the main driver of execution on a list of targets. It first
+    # groups targets by transport, then divides each group into batches as
+    # defined by the transport. Each batch, along with the corresponding
+    # transport, is yielded to the block in turn and the results all collected
+    # into a single ResultSet.
+    def batch_execute(targets, &block)
+      promises = queue_execute(targets, &block)
+      await_results(promises)
+    end
+
     def log_action(description, targets)
       # When running a plan, info messages like starting a task are promoted to notice.
       log_method = @plan_logging ? :notice : :info
@@ -115,7 +134,6 @@ module Bolt
 
       results
     end
-    private :log_action
 
     def report_transport(transport, count)
       name = transport.class.name.split('::').last.downcase
@@ -127,13 +145,18 @@ module Bolt
       @analytics&.event('Plan', 'call_function', function)
     end
 
+    def report_bundled_content(mode, name)
+      if @bundled_content&.include?(name)
+        @analytics&.event('Bundled Content', mode, name)
+      end
+    end
+
     def with_node_logging(description, batch)
       @logger.info("#{description} on #{batch.map(&:uri)}")
       result = yield
       @logger.info(result.to_json)
       result
     end
-    private :with_node_logging
 
     def run_command(targets, command, options = {}, &callback)
       description = options.fetch('_description', "command '#{command}'")

data/lib/bolt/pal.rb

@@ -119,7 +119,14 @@ module Bolt
         bolt_executor: executor,
         bolt_inventory: inventory,
         bolt_pdb_client: pdb_client,
-        apply_executor: Applicator.new(inventory, executor)
+        apply_executor: Applicator.new(
+          inventory,
+          executor,
+          full_modulepath(@config[:modulepath]),
+          @config.puppetdb,
+          @config[:'hiera-config'],
+          @config[:'compile-concurrency']
+        )
       }
       Puppet.override(opts, &block)
     end

data/lib/bolt/transport/ssh.rb

@@ -132,6 +132,7 @@ module Bolt
 
             if ENVIRONMENT_METHODS.include?(input_method)
               environment = arguments.inject({}) do |env, (param, val)|
+                val = val.to_json unless val.is_a?(String)
                 env.merge("PT_#{param}" => val)
               end
               execute_options[:environment] = environment

data/lib/bolt/transport/winrm.rb

@@ -112,6 +112,7 @@ catch
 
           if ENVIRONMENT_METHODS.include?(input_method)
             arguments.each do |(arg, val)|
+              val = val.to_json unless val.is_a?(String)
               cmd = "[Environment]::SetEnvironmentVariable('PT_#{arg}', @'\n#{val}\n'@)"
               result = conn.execute(cmd)
               if result.exit_code != 0

data/lib/bolt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bolt
-  VERSION = '0.21.2'
+  VERSION = '0.21.3'
 end

data/libexec/bolt_catalog

@@ -7,12 +7,15 @@ require 'json'
 
 # This accepts a catalog request on stdin:
 # { "code_ast": "JSON serialized Puppet AST",
-#   "code_string": "String of code, ignored if AST is provided,
-#   "modulepath": "Array of directories to use as the modulepath for catalog compilation.
+#   "code_string": "String of code, ignored if AST is provided",
+#   "modulepath": "Array of directories to use as the modulepath for catalog compilation",
+#   "pdb_config": "A hash of PDB client config options as supplied to Bolt",
+#   "hiera_config": "File path to hiera config file",
 #   "target": {
-#   "name": "the name of the node usually fqdn fro url",
-#   "facts": "Hash of facts to use for the node",
-#   "variables": "Hash of variables to use for compilation"
+#     "name": "the name of the node usually fqdn fro url",
+#     "facts": "Hash of facts to use for the node",
+#     "variables": "Hash of variables to use for compilation",
+#     "trusted": "Hash of trusted data for the node"
 #   }
 # }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 0.21.2
+  version: 0.21.3
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-09 00:00:00.000000000 Z
+date: 2018-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.4
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.4
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: terminal-table
   requirement: !ruby/object:Gem::Requirement
@@ -198,14 +198,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement