hotdog 0.18.3 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e1028a5f20aa3186fb10d14ea6442de32afd7f23
-  data.tar.gz: 5737e3411463b9be5d49646995b269d6f0c68d94
+  metadata.gz: 872d3fc9b9a8db571e76a8ecd479302eb3320182
+  data.tar.gz: e5f2a0a7fca123a5895cbb6b0938588e3fb82383
 SHA512:
-  metadata.gz: a8ff94f92bfd4bfb3816a24715ece125ba0d61a162ae35e436ed9ad793e8bd52387daa45d2fed3dd7fd1dabd420c10f8671d841aafbbea279dc7ad7d9d3faf3f
-  data.tar.gz: e09c12120df40d689603e7b087e5c38686080347da012ae91d406eaf9b9be8d060101925794ebeaea04db65aaeef1dba279a0045a67cb5fb305b07fd226b1d98
+  metadata.gz: 12b4a016471a39f25e02214122d5a4baed9c57f40dd1527a5823cf32650cafce216bfa45d6d2680dda0885775851fec40944faf815d84444cc5184a994d9777c
+  data.tar.gz: fe92243179aa734f40a63a06848e026ba6cc9b315db6aa0cd5efd8ad8cfda4331af8af9f58bb64ee0453f0a2b91347e2d861f77008e62f1ad354129d79adeeeb

data/.travis.yml

@@ -1,8 +1,8 @@
 language: ruby
 rvm:
-  - 2.1.6
-  - 2.2.5
-  - 2.3.1
+  - 2.1.10
+  - 2.2.6
+  - 2.3.3
 script:
   - rspec spec
 sudo: false

data/lib/hotdog/application.rb

@@ -96,7 +96,7 @@ module Hotdog
       rescue Errno::EPIPE => error
         STDERR.puts(error)
       rescue => error
-        STDERR.puts(error)
+        STDERR.puts("#{error.class}: #{error} at #{caller.first}")
         if @options[:debug]
           raise # to show error stacktrace
         else

data/lib/hotdog/commands/down.rb

@@ -39,8 +39,8 @@ module Hotdog
             with_retry do
               @db.transaction do
                 hosts.each_slice(SQLITE_LIMIT_COMPOUND_SELECT) do |hosts|
-                  execute_db(@db, "DELETE FROM hosts_tags WHERE host_id IN ( SELECT id FROM hosts WHERE name IN (%s) )" % hosts.map { "?" }.join(", "), hosts)
-                  execute_db(@db, "DELETE FROM hosts WHERE name IN (%s)" % hosts.map { "?" }.join(", "), hosts)
+                  execute_db(@db, "DELETE FROM hosts_tags WHERE host_id IN ( SELECT id FROM hosts WHERE name IN (%s) );" % hosts.map { "?" }.join(", "), hosts)
+                  execute_db(@db, "DELETE FROM hosts WHERE name IN (%s);" % hosts.map { "?" }.join(", "), hosts)
                 end
               end
             end

data/lib/hotdog/commands/scp.rb

@@ -10,7 +10,7 @@ module Hotdog
       private
       def build_command_string(host, command=nil, options={})
         # replace "@:" by actual hostname
-        cmdline = ["scp"] + build_command_options(options) + Shellwords.split(command).map { |token| token.gsub(/@(?=:)/, host) }
+        cmdline = Shellwords.shellsplit(options.fetch(:scp_command, "scp")) + build_command_options(options) + Shellwords.split(command).map { |token| token.gsub(/@(?=:)/, host) }
         Shellwords.join(cmdline)
       end
     end

data/lib/hotdog/commands/sftp.rb

@@ -9,7 +9,7 @@ module Hotdog
     class Sftp < SingularSshAlike
       private
       def build_command_string(host, command=nil, options={})
-        cmdline = ["sftp"] + build_command_options(options) + [host]
+        cmdline = Shellwords.shellsplit(options.fetch(:sftp_command, "sftp")) + build_command_options(options) + [host]
         if command
           logger.warn("ignore remote command: #{command}")
         end

data/lib/hotdog/commands/ssh.rb

@@ -132,7 +132,7 @@ module Hotdog
 
       def build_command_string(host, command=nil, options={})
         # build ssh command
-        cmdline = ["ssh"] + build_command_options(options) + [host]
+        cmdline = Shellwords.shellsplit(options.fetch(:ssh_command, "ssh")) + build_command_options(options) + [host]
         if command
           cmdline << "--" << command
         end

data/lib/hotdog/commands/untag.rb

@@ -30,7 +30,7 @@ module Hotdog
 
         if options[:tags].empty?
           # refresh all persistent.db since there is no way to identify user tags
-          remove_db
+          remove_db(@db)
         else
           if open_db
             with_retry do

data/lib/hotdog/commands/up.rb

@@ -43,7 +43,7 @@ module Hotdog
         }
         if 0 < hosts.length
           # refresh all persistent.db to retrieve information about up'd host
-          remove_db
+          remove_db(@db)
         end
       end
 

data/lib/hotdog/commands.rb

@@ -119,7 +119,7 @@ module Hotdog
         host_ids.each_slice(SQLITE_LIMIT_COMPOUND_SELECT).flat_map { |host_ids|
           q = "SELECT DISTINCT tags.name FROM hosts_tags " \
                 "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
-                  "WHERE hosts_tags.host_id IN (%s);" % host_ids.map { "?" }.join(", ")
+                  "WHERE hosts_tags.host_id IN (%s) ORDER BY hosts_tags.host_id;" % host_ids.map { "?" }.join(", ")
           execute(q, host_ids).map { |row| row.first }
         }.uniq
       end
@@ -131,20 +131,13 @@ module Hotdog
         when 1
           get_hosts_field(host_ids, fields.first, options)
         else
-          if fields.find { |field| /\Ahost\z/i =~ field }
-            host_names = Hash[execute("SELECT id, name FROM hosts WHERE id IN (%s);" % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.to_a }]
-          else
-            host_names = {}
-          end
-
-          [host_ids.map { |host_id| get_host_fields(host_id, fields, options.merge(host_names: host_names)) }.map { |result, fields| result }, fields]
+          [host_ids.map { |host_id| get_host_fields(host_id, fields, options) }.map { |result, fields| result }, fields]
         end
       end
 
       def get_host_fields(host_id, fields, options={})
-        field_values = {"host" => options.fetch(:host_names, {}).fetch(host_id, nil)}
-
-        fields.reject { |field| /\Ahost\z/i =~ field }.uniq.each_slice(SQLITE_LIMIT_COMPOUND_SELECT - 1).each do |fields|
+        field_values = {}
+        fields.uniq.each_slice(SQLITE_LIMIT_COMPOUND_SELECT - 1).each do |fields|
           q = "SELECT LOWER(tags.name), GROUP_CONCAT(tags.value, ',') FROM hosts_tags " \
                 "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
                   "WHERE hosts_tags.host_id = ? AND tags.name IN (%s) " \
@@ -164,14 +157,14 @@ module Hotdog
       def get_hosts_field(host_ids, field, options={})
         if /\Ahost\z/i =~ field
           result = host_ids.each_slice(SQLITE_LIMIT_COMPOUND_SELECT).flat_map { |host_ids|
-            execute("SELECT name FROM hosts WHERE id IN (%s)" % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.to_a }
+            execute("SELECT name FROM hosts WHERE id IN (%s) ORDER BY id;" % host_ids.map { "?" }.join(", "), host_ids).map { |row| row.to_a }
           }
         else
           result = host_ids.each_slice(SQLITE_LIMIT_COMPOUND_SELECT - 1).flat_map { |host_ids|
             q = "SELECT LOWER(tags.name), GROUP_CONCAT(tags.value, ',') FROM hosts_tags " \
                   "INNER JOIN tags ON hosts_tags.tag_id = tags.id " \
                     "WHERE hosts_tags.host_id IN (%s) AND tags.name = ? " \
-                      "GROUP BY hosts_tags.host_id, tags.name;" % host_ids.map { "?" }.join(", ")
+                      "GROUP BY hosts_tags.host_id, tags.name ORDER BY hosts_tags.host_id;" % host_ids.map { "?" }.join(", ")
             r = execute(q, host_ids + [field]).map { |tag_name, tag_value|
               [display_tag(tag_name, tag_value)]
             }
@@ -211,12 +204,10 @@ module Hotdog
         if @db
           @db
         else
-          FileUtils.mkdir_p(options[:confdir])
-          persistent = File.join(options[:confdir], PERSISTENT_DB)
-
-          if (not options[:force] and File.exist?(persistent) and Time.new < File.mtime(persistent) + options[:expiry]) or options[:offline]
+          FileUtils.mkdir_p(File.dirname(persistent_db_path))
+          if not options[:force] or options[:offline] or (File.exist?(persistent_db_path) and Time.new < (File.mtime(persistent_db_path) + options[:expiry]))
             begin
-              persistent_db = SQLite3::Database.new(persistent)
+              persistent_db = SQLite3::Database.new(persistent_db_path)
               persistent_db.execute("SELECT hosts_tags.host_id FROM hosts_tags INNER JOIN hosts ON hosts_tags.host_id = hosts.id INNER JOIN tags ON hosts_tags.tag_id = tags.id LIMIT 1;")
               @db = persistent_db
             rescue SQLite3::BusyException
@@ -239,45 +230,50 @@ module Hotdog
         if open_db(options)
           @db
         else
-          memory_db = SQLite3::Database.new(":memory:")
-          execute_db(memory_db, "CREATE TABLE IF NOT EXISTS hosts (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(255) NOT NULL COLLATE NOCASE);")
-          execute_db(memory_db, "CREATE UNIQUE INDEX IF NOT EXISTS hosts_name ON hosts (name);")
-          execute_db(memory_db, "CREATE TABLE IF NOT EXISTS tags (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(200) NOT NULL COLLATE NOCASE, value VARCHAR(200) NOT NULL COLLATE NOCASE);")
-          execute_db(memory_db, "CREATE UNIQUE INDEX IF NOT EXISTS tags_name_value ON tags (name, value);")
-          execute_db(memory_db, "CREATE TABLE IF NOT EXISTS hosts_tags (host_id INTEGER NOT NULL, tag_id INTEGER NOT NULL);")
-          execute_db(memory_db, "CREATE UNIQUE INDEX IF NOT EXISTS hosts_tags_host_id_tag_id ON hosts_tags (host_id, tag_id);")
+          memory_db = create_db(SQLite3::Database.new(":memory:"), options)
+          # backup in-memory db to file
+          FileUtils.mkdir_p(File.dirname(persistent_db_path))
+          persistent_db = SQLite3::Database.new(persistent_db_path)
+          copy_db(memory_db, persistent_db)
+          close_db(memory_db)
+          @db = persistent_db
+        end
+      end
 
-          all_tags = get_all_tags()
+      def create_db(db, options={})
+        options = @options.merge(options)
+        execute_db(db, "CREATE TABLE IF NOT EXISTS hosts (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(255) NOT NULL COLLATE NOCASE);")
+        execute_db(db, "CREATE UNIQUE INDEX IF NOT EXISTS hosts_name ON hosts (name);")
+        execute_db(db, "CREATE TABLE IF NOT EXISTS tags (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(200) NOT NULL COLLATE NOCASE, value VARCHAR(200) NOT NULL COLLATE NOCASE);")
+        execute_db(db, "CREATE UNIQUE INDEX IF NOT EXISTS tags_name_value ON tags (name, value);")
+        execute_db(db, "CREATE TABLE IF NOT EXISTS hosts_tags (host_id INTEGER NOT NULL, tag_id INTEGER NOT NULL);")
+        execute_db(db, "CREATE UNIQUE INDEX IF NOT EXISTS hosts_tags_host_id_tag_id ON hosts_tags (host_id, tag_id);")
 
-          memory_db.transaction do
-            known_tags = all_tags.keys.map { |tag| split_tag(tag) }.uniq
-            create_tags(memory_db, known_tags)
+        all_tags = get_all_tags()
 
-            known_hosts = all_tags.values.reduce(:+).uniq
-            create_hosts(memory_db, known_hosts)
+        db.transaction do
+          known_tags = all_tags.keys.map { |tag| split_tag(tag) }.uniq
+          create_tags(db, known_tags)
 
-            all_tags.each do |tag, hosts|
-              associate_tag_hosts(memory_db, tag, hosts)
-            end
-          end
+          known_hosts = all_tags.values.reduce(:+).uniq
+          create_hosts(db, known_hosts)
 
-          # backup in-memory db to file
-          FileUtils.mkdir_p(options[:confdir])
-          persistent = File.join(options[:confdir], PERSISTENT_DB)
-          FileUtils.rm_f(persistent)
-          persistent_db = SQLite3::Database.new(persistent)
-          copy_db(memory_db, persistent_db)
-          close_db(memory_db)
-          @db = persistent_db
+          all_tags.each do |tag, hosts|
+            associate_tag_hosts(db, tag, hosts)
+          end
         end
+
+        db
       end
 
-      def remove_db(options={})
+      def remove_db(db, options={})
         options = @options.merge(options)
-        if @db
-          close_db(@db)
+        if db
+          close_db(db)
+        end
+        if File.exist?(persistent_db_path)
+          FileUtils.touch(persistent_db_path, mtime: Time.new - options[:expiry])
         end
-        FileUtils.rm_f(File.join(options[:confdir], PERSISTENT_DB))
       end
 
       def execute_db(db, q, args=[])
@@ -329,22 +325,29 @@ module Hotdog
           q = "INSERT OR IGNORE INTO hosts (name) VALUES %s" % hosts.map { "(?)" }.join(", ")
           execute_db(db, q, hosts)
         end
+        # create virtual `host` tag
+        execute_db(db, "INSERT OR IGNORE INTO tags (name, value) SELECT 'host', hosts.name FROM hosts;")
+        q = "INSERT OR REPLACE INTO hosts_tags (host_id, tag_id) " \
+              "SELECT hosts.id, tags.id FROM hosts " \
+                "INNER JOIN ( SELECT * FROM tags WHERE name = 'host' ) AS tags " \
+                  "ON hosts.name = tags.value;"
+        execute_db(db, q)
       end
 
       def create_tags(db, tags)
         tags.each_slice(SQLITE_LIMIT_COMPOUND_SELECT / 2) do |tags|
-          q = "INSERT OR IGNORE INTO tags (name, value) VALUES %s" % tags.map { "(?, ?)" }.join(", ")
+          q = "INSERT OR IGNORE INTO tags (name, value) VALUES %s;" % tags.map { "(?, ?)" }.join(", ")
           execute_db(db, q, tags)
         end
       end
 
       def associate_tag_hosts(db, tag, hosts)
         hosts.each_slice(SQLITE_LIMIT_COMPOUND_SELECT - 2) do |hosts|
-          q = "INSERT OR REPLACE INTO hosts_tags (host_id, tag_id) " \
-                "SELECT host.id, tag.id FROM " \
-                  "( SELECT id FROM hosts WHERE name IN (%s) ) AS host, " \
-                  "( SELECT id FROM tags WHERE name = ? AND value = ? LIMIT 1 ) AS tag;" % hosts.map { "?" }.join(", ")
           begin
+            q = "INSERT OR REPLACE INTO hosts_tags (host_id, tag_id) " \
+                  "SELECT host.id, tag.id FROM " \
+                    "( SELECT id FROM hosts WHERE name IN (%s) ) AS host, " \
+                    "( SELECT id FROM tags WHERE name = ? AND value = ? LIMIT 1 ) AS tag;" % hosts.map { "?" }.join(", ")
             execute_db(db, q, (hosts + split_tag(tag)))
           rescue SQLite3::RangeException => error
             # FIXME: bulk insert occationally fails even if there are no errors in bind parameters
@@ -364,8 +367,7 @@ module Hotdog
       def disassociate_tag_hosts(db, tag, hosts)
         hosts.each_slice(SQLITE_LIMIT_COMPOUND_SELECT - 2) do |hosts|
           q = "DELETE FROM hosts_tags " \
-                "WHERE tag_id IN ( SELECT id FROM tags WHERE name = ? AND value = ? LIMIT 1 );" \
-                  "AND host_id IN ( SELECT id FROM hosts WHERE name IN (%s) ) " % hosts.map { "?" }.join(", ")
+                "WHERE tag_id IN ( SELECT id FROM tags WHERE name = ? AND value = ? LIMIT 1 ) AND host_id IN ( SELECT id FROM hosts WHERE name IN (%s) );" % hosts.map { "?" }.join(", ")
           execute_db(db, q, split_tag(tag) + hosts)
         end
       end
@@ -404,6 +406,10 @@ module Hotdog
         end
         raise("retry count exceeded")
       end
+
+      def persistent_db_path()
+        File.join(options[:confdir], PERSISTENT_DB)
+      end
     end
   end
 end

data/lib/hotdog/expression/semantics.rb

@@ -41,7 +41,7 @@ module Hotdog
             end
           else
             # workaround for "too many terms in compound SELECT"
-            min, max = environment.execute("SELECT MIN(id), MAX(id) FROM hosts ORDER BY id LIMIT 1").first.to_a
+            min, max = environment.execute("SELECT MIN(id), MAX(id) FROM hosts LIMIT 1;").first.to_a
             (min / (SQLITE_LIMIT_COMPOUND_SELECT - 2)).upto(max / (SQLITE_LIMIT_COMPOUND_SELECT - 2)).flat_map { |i|
               range = ((SQLITE_LIMIT_COMPOUND_SELECT - 2) * i)...((SQLITE_LIMIT_COMPOUND_SELECT - 2) * (i + 1))
               selected = values.select { |n| range === n }
@@ -150,7 +150,7 @@ module Hotdog
               []
             else
               # workaround for "too many terms in compound SELECT"
-              min, max = environment.execute("SELECT MIN(id), MAX(id) FROM hosts ORDER BY id LIMIT 1").first.to_a
+              min, max = environment.execute("SELECT MIN(id), MAX(id) FROM hosts LIMIT 1;").first.to_a
               (min / ((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2)).upto(max / ((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2)).flat_map { |i|
                 range = (((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2) * i)...(((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2) * (i + 1))
                 left_selected = left_values.select { |n| range === n }
@@ -177,7 +177,7 @@ module Hotdog
               []
             else
               # workaround for "too many terms in compound SELECT"
-              min, max = environment.execute("SELECT MIN(id), MAX(id) FROM hosts ORDER BY id LIMIT 1").first.to_a
+              min, max = environment.execute("SELECT MIN(id), MAX(id) FROM hosts LIMIT 1;").first.to_a
               (min / ((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2)).upto(max / ((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2)).flat_map { |i|
                 range = (((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2) * i)...(((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 2) * (i + 1))
                 left_selected = left_values.select { |n| range === n }
@@ -204,7 +204,7 @@ module Hotdog
               []
             else
               # workaround for "too many terms in compound SELECT"
-              min, max = environment.execute("SELECT MIN(id), MAX(id) FROM hosts ORDER BY id LIMIT 1").first.to_a
+              min, max = environment.execute("SELECT MIN(id), MAX(id) FROM hosts LIMIT 1;").first.to_a
               (min / ((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 4)).upto(max / ((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 4)).flat_map { |i|
                 range = (((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 4) * i)...(((SQLITE_LIMIT_COMPOUND_SELECT - 2) / 4) * (i + 1))
                 left_selected = left_values.select { |n| range === n }
@@ -529,7 +529,7 @@ module Hotdog
 
     class EverythingNode < QueryExpressionNode
       def initialize(options={})
-        super("SELECT id AS host_id FROM hosts", [], options)
+        super("SELECT id AS host_id FROM hosts;", [], options)
       end
     end
 

data/lib/hotdog/version.rb

@@ -1,3 +1,3 @@
 module Hotdog
-  VERSION = "0.18.3"
+  VERSION = "0.19.0"
 end

data/spec/core/commands_spec.rb

@@ -51,7 +51,7 @@ describe "commands" do
     q1 = [
       "SELECT DISTINCT tags.name FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
-          "WHERE hosts_tags.host_id IN (?, ?, ?);",
+          "WHERE hosts_tags.host_id IN (?, ?, ?) ORDER BY hosts_tags.host_id;",
     ]
     allow(cmd).to receive(:execute).with(q1.join(" "), [1, 2, 3]) {
       [["foo"], ["bar"], ["baz"]]
@@ -67,7 +67,7 @@ describe "commands" do
     q1 = [
       "SELECT DISTINCT tags.name FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
-          "WHERE hosts_tags.host_id IN (?, ?, ?);",
+          "WHERE hosts_tags.host_id IN (?, ?, ?) ORDER BY hosts_tags.host_id;",
     ]
     allow(cmd).to receive(:execute).with(q1.join(" "), [1, 2, 3]) {
       [["foo"], ["bar"], ["baz"]]
@@ -100,23 +100,20 @@ describe "commands" do
   end
 
   it "get host fields with host" do
-    allow(cmd).to receive(:execute).with("SELECT id, name FROM hosts WHERE id IN (?, ?, ?);", [1, 2, 3]) {
-      [[1, "host1"], [2, "host2"], [3, "host3"]]
-    }
     q1 = [
       "SELECT LOWER(tags.name), GROUP_CONCAT(tags.value, ',') FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
-          "WHERE hosts_tags.host_id = ? AND tags.name IN (?, ?)",
+          "WHERE hosts_tags.host_id = ? AND tags.name IN (?, ?, ?)",
             "GROUP BY tags.name;",
     ]
-    allow(cmd).to receive(:execute).with(q1.join(" "), [1, "foo", "bar"]) {
-      [["foo", "foo1"], ["bar", "bar1"]]
+    allow(cmd).to receive(:execute).with(q1.join(" "), [1, "foo", "bar", "host"]) {
+      [["foo", "foo1"], ["bar", "bar1"], ["host", "host1"]]
     }
-    allow(cmd).to receive(:execute).with(q1.join(" "), [2, "foo", "bar"]) {
-      [["foo", "foo2"], ["bar", "bar2"]]
+    allow(cmd).to receive(:execute).with(q1.join(" "), [2, "foo", "bar", "host"]) {
+      [["foo", "foo2"], ["bar", "bar2"], ["host", "host2"]]
     }
-    allow(cmd).to receive(:execute).with(q1.join(" "), [3, "foo", "bar"]) {
-      [["foo", "foo3"], ["bar", "bar3"]]
+    allow(cmd).to receive(:execute).with(q1.join(" "), [3, "foo", "bar", "host"]) {
+      [["foo", "foo3"], ["bar", "bar3"], ["host", "host3"]]
     }
     expect(cmd.__send__(:get_hosts_fields, [1, 2, 3], ["foo", "bar", "host"])).to eq([[["foo1", "bar1", "host1"], ["foo2", "bar2", "host2"], ["foo3", "bar3", "host3"]], ["foo", "bar", "host"]])
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hotdog
 version: !ruby/object:Gem::Version
-  version: 0.18.3
+  version: 0.19.0
 platform: ruby
 authors:
 - Yamashita Yuu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-13 00:00:00.000000000 Z
+date: 2016-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -237,7 +237,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Yet another command-line tool for Datadog