train 2.1.7 → 2.1.13

data/lib/train/platforms/detect/helpers/os_linux.rb

@@ -3,7 +3,7 @@
 module Train::Platforms::Detect::Helpers
   module Linux
     def redhatish_platform(conf)
-      conf =~ /^red hat/i ? 'redhat' : /(\w+)/i.match(conf)[1].downcase
+      conf =~ /^red hat/i ? "redhat" : /(\w+)/i.match(conf)[1].downcase
     end
 
     def redhatish_version(conf)
@@ -20,11 +20,11 @@ module Train::Platforms::Detect::Helpers
     end
 
     def linux_os_release
-      data = unix_file_contents('/etc/os-release')
+      data = unix_file_contents("/etc/os-release")
       return if data.nil?
 
       os_info = parse_os_release_info(data)
-      cisco_info_file = os_info['CISCO_RELEASE_INFO']
+      cisco_info_file = os_info["CISCO_RELEASE_INFO"]
       if cisco_info_file
         os_info.merge!(parse_os_release_info(unix_file_contents(cisco_info_file)))
       end
@@ -37,10 +37,10 @@ module Train::Platforms::Detect::Helpers
 
       raw.lines.each_with_object({}) do |line, memo|
         line.strip!
-        next if line.start_with?('#')
+        next if line.start_with?("#")
         next if line.empty?
-        key, value = line.split('=', 2)
-        memo[key] = value.gsub(/\A"|"\Z/, '') unless value.empty?
+        key, value = line.split("=", 2)
+        memo[key] = value.gsub(/\A"|"\Z/, "") unless value.empty?
       end
     end
 
@@ -49,8 +49,8 @@ module Train::Platforms::Detect::Helpers
       release = /^DISTRIB_RELEASE=["']?(.+?)["']?$/.match(content)
       codename = /^DISTRIB_CODENAME=["']?(.+?)["']?$/.match(content)
       {
-        id:       id.nil? ? nil : id[1],
-        release:  release.nil? ? nil : release[1],
+        id: id.nil? ? nil : id[1],
+        release: release.nil? ? nil : release[1],
         codename: codename.nil? ? nil : codename[1],
       }
     end
@@ -60,17 +60,17 @@ module Train::Platforms::Detect::Helpers
       release = /^Release:\s+(.+)$/.match(content)
       codename = /^Codename:\s+(.+)$/.match(content)
       {
-        id:       id.nil? ? nil : id[1],
-        release:  release.nil? ? nil : release[1],
+        id: id.nil? ? nil : id[1],
+        release: release.nil? ? nil : release[1],
         codename: codename.nil? ? nil : codename[1],
       }
     end
 
     def read_linux_lsb
       return @lsb unless @lsb.empty?
-      if !(raw = unix_file_contents('/etc/lsb-release')).nil?
+      if !(raw = unix_file_contents("/etc/lsb-release")).nil?
         @lsb = lsb_config(raw)
-      elsif !(raw = unix_file_contents('/usr/bin/lsb-release')).nil?
+      elsif !(raw = unix_file_contents("/usr/bin/lsb-release")).nil?
         @lsb = lsb_release(raw)
       end
     end

data/lib/train/platforms/detect/helpers/os_windows.rb

@@ -1,22 +1,20 @@
-# encoding: utf-8
-
 module Train::Platforms::Detect::Helpers
   module Windows
     def detect_windows
       # try to detect windows, use cmd.exe to also support Microsoft OpenSSH
-      res = @backend.run_command('cmd.exe /c ver')
-      return false if res.exit_status != 0 or res.stdout.empty?
+      res = @backend.run_command("cmd.exe /c ver")
+      return false if (res.exit_status != 0) || res.stdout.empty?
 
       # if the ver contains `Windows`, we know its a Windows system
       version = res.stdout.strip
       return false unless version.downcase =~ /windows/
-      @platform[:family] = 'windows'
+      @platform[:family] = "windows"
 
       # try to extract release from eg. `Microsoft Windows [Version 6.3.9600]`
       release = /\[(?<name>.*)\]/.match(version)
       unless release[:name].nil?
         # release is 6.3.9600 now
-        @platform[:release] = release[:name].downcase.gsub('version', '').strip
+        @platform[:release] = release[:name].downcase.gsub("version", "").strip
         # fallback, if we are not able to extract the name from wmic later
         @platform[:name] = "Windows #{@platform[:release]}"
       end
@@ -31,19 +29,19 @@ module Train::Platforms::Detect::Helpers
     # @see https://msdn.microsoft.com/en-us/library/bb742610.aspx#EEAA
     # Thanks to Matt Wrock (https://github.com/mwrock) for this hint
     def read_wmic
-      res = @backend.run_command('wmic os get * /format:list')
+      res = @backend.run_command("wmic os get * /format:list")
       if res.exit_status == 0
         sys_info = {}
-        res.stdout.lines.each { |line|
+        res.stdout.lines.each do |line|
           m = /^\s*([^=]*?)\s*=\s*(.*?)\s*$/.match(line)
           sys_info[m[1].to_sym] = m[2] unless m.nil? || m[1].nil?
-        }
+        end
 
         @platform[:release] = sys_info[:Version]
         # additional info on windows
         @platform[:build] = sys_info[:BuildNumber]
         @platform[:name] = sys_info[:Caption]
-        @platform[:name] = @platform[:name].gsub('Microsoft', '').strip unless @platform[:name].empty?
+        @platform[:name] = @platform[:name].gsub("Microsoft", "").strip unless @platform[:name].empty?
         @platform[:arch] = read_wmic_cpu
       end
     end
@@ -51,25 +49,25 @@ module Train::Platforms::Detect::Helpers
     # `OSArchitecture` from `read_wmic` does not match a normal standard
     # For example, `x86_64` shows as `64-bit`
     def read_wmic_cpu
-      res = @backend.run_command('wmic cpu get architecture /format:list')
+      res = @backend.run_command("wmic cpu get architecture /format:list")
       if res.exit_status == 0
         sys_info = {}
-        res.stdout.lines.each { |line|
+        res.stdout.lines.each do |line|
           m = /^\s*([^=]*?)\s*=\s*(.*?)\s*$/.match(line)
           sys_info[m[1].to_sym] = m[2] unless m.nil? || m[1].nil?
-        }
+        end
       end
 
       # This converts `wmic os get architecture` output to a normal standard
       # https://msdn.microsoft.com/en-us/library/aa394373(VS.85).aspx
       arch_map = {
-        0 => 'i386',
-        1 => 'mips',
-        2 => 'alpha',
-        3 => 'powerpc',
-        5 => 'arm',
-        6 => 'ia64',
-        9 => 'x86_64',
+        0 => "i386",
+        1 => "mips",
+        2 => "alpha",
+        3 => "powerpc",
+        5 => "arm",
+        6 => "ia64",
+        9 => "x86_64",
       }
 
       # The value of `wmic cpu get architecture` is always a number between 0-9
@@ -83,38 +81,38 @@ module Train::Platforms::Detect::Helpers
       uuid = windows_uuid_from_machine_file if uuid.nil?
       uuid = windows_uuid_from_wmic if uuid.nil?
       uuid = windows_uuid_from_registry if uuid.nil?
-      raise Train::TransportError, 'Cannot find a UUID for your node.' if uuid.nil?
+      raise Train::TransportError, "Cannot find a UUID for your node." if uuid.nil?
       uuid
     end
 
     def windows_uuid_from_machine_file
-      %W(
+      %W{
         #{ENV['SYSTEMDRIVE']}\\chef\\chef_guid
         #{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}\\.chef\\chef_guid
-      ).each do |path|
+      }.each do |path|
         file = @backend.file(path)
-        return file.content.chomp if file.exist? && !file.size.zero?
+        return file.content.chomp if file.exist? && file.size != 0
       end
       nil
     end
 
     def windows_uuid_from_chef
       file = @backend.file("#{ENV['SYSTEMDRIVE']}\\chef\\cache\\data_collector_metadata.json")
-      return if !file.exist? || file.size.zero?
+      return if !file.exist? || file.size == 0
       json = JSON.parse(file.content)
-      json['node_uuid'] if json['node_uuid']
+      json["node_uuid"] if json["node_uuid"]
     end
 
     def windows_uuid_from_wmic
-      result = @backend.run_command('wmic csproduct get UUID')
-      return unless result.exit_status.zero?
+      result = @backend.run_command("wmic csproduct get UUID")
+      return unless result.exit_status == 0
       result.stdout.split("\r\n")[-1].strip
     end
 
     def windows_uuid_from_registry
       cmd = '(Get-ItemProperty "Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Cryptography" -Name "MachineGuid")."MachineGuid"'
       result = @backend.run_command(cmd)
-      return unless result.exit_status.zero?
+      return unless result.exit_status == 0
       result.stdout.chomp
     end
   end

data/lib/train/platforms/detect/scanner.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-require 'train/platforms/detect/helpers/os_common'
+require "train/platforms/detect/helpers/os_common"
 
 module Train::Platforms::Detect
   class Scanner
@@ -38,7 +38,7 @@ module Train::Platforms::Detect
         return get_platform(plat_result)
       end
 
-      fail Train::PlatformDetectionFailed, 'Sorry, we are unable to detect your platform'
+      raise Train::PlatformDetectionFailed, "Sorry, we are unable to detect your platform"
     end
 
     def scan_children(parent)
@@ -65,8 +65,8 @@ module Train::Platforms::Detect
 
     def check_condition(condition)
       condition.each do |k, v|
-        op, expected = v.strip.split(' ')
-        op = '==' if op == '='
+        op, expected = v.strip.split(" ")
+        op = "==" if op == "="
         return false if @platform[k].nil? || !instance_eval("'#{@platform[k]}' #{op} '#{expected}'")
       end
 

data/lib/train/platforms/detect/specifications/api.rb

@@ -5,16 +5,16 @@ module Train::Platforms::Detect::Specifications
     def self.load
       plat = Train::Platforms
 
-      plat.family('api')
+      plat.family("api")
 
-      plat.family('cloud').in_family('api')
-      plat.name('aws').in_family('cloud')
-      plat.name('azure').in_family('cloud')
-      plat.name('gcp').in_family('cloud')
-      plat.name('vmware').in_family('cloud')
+      plat.family("cloud").in_family("api")
+      plat.name("aws").in_family("cloud")
+      plat.name("azure").in_family("cloud")
+      plat.name("gcp").in_family("cloud")
+      plat.name("vmware").in_family("cloud")
 
-      plat.family('iaas').in_family('api')
-      plat.name('oneview').in_family('iaas')
+      plat.family("iaas").in_family("api")
+      plat.name("oneview").in_family("iaas")
     end
   end
 end

data/lib/train/platforms/detect/specifications/os.rb

@@ -13,15 +13,15 @@ module Train::Platforms::Detect::Specifications
       plat = Train::Platforms
 
       # master family
-      plat.family('os').detect { true }
+      plat.family("os").detect { true }
 
-      plat.family('windows').in_family('os')
-          .detect {
+      plat.family("windows").in_family("os")
+          .detect do
             # Can't return from a `proc` thus the `is_windows` shenanigans
             is_windows = false
             is_windows = true if winrm?
 
-            if @backend.class.to_s == 'Train::Transports::Local::Connection'
+            if @backend.class.to_s == "Train::Transports::Local::Connection"
               is_windows = true if ruby_host_os(/mswin|mingw32|windows/)
             end
 
@@ -31,61 +31,61 @@ module Train::Platforms::Detect::Specifications
             end
 
             is_windows
-          }
+          end
       # windows platform
-      plat.name('windows').in_family('windows')
-          .detect {
+      plat.name("windows").in_family("windows")
+          .detect do
             true if detect_windows == true
-          }
+          end
 
       # unix master family
-      plat.family('unix').in_family('os')
-          .detect {
+      plat.family("unix").in_family("os")
+          .detect do
             # we want to catch a special case here where cisco commands
             # don't return an exit status and still print to stdout
-            if unix_uname_s =~ /./ && !unix_uname_s.start_with?('Line has invalid autocommand ') && !unix_uname_s.start_with?('The command you have entered')
+            if unix_uname_s =~ /./ && !unix_uname_s.start_with?("Line has invalid autocommand ") && !unix_uname_s.start_with?("The command you have entered")
               @platform[:arch] = unix_uname_m
               true
             end
-          }
+          end
 
       # linux master family
-      plat.family('linux').in_family('unix')
-          .detect {
+      plat.family("linux").in_family("unix")
+          .detect do
             true if unix_uname_s =~ /linux/i
-          }
+          end
 
       # debian family
-      plat.family('debian').in_family('linux')
-          .detect {
-            true unless unix_file_contents('/etc/debian_version').nil?
-          }
-      plat.name('ubuntu').title('Ubuntu Linux').in_family('debian')
-          .detect {
+      plat.family("debian").in_family("linux")
+          .detect do
+            true unless unix_file_contents("/etc/debian_version").nil?
+          end
+      plat.name("ubuntu").title("Ubuntu Linux").in_family("debian")
+          .detect do
             lsb = read_linux_lsb
             if lsb && lsb[:id] =~ /ubuntu/i
               @platform[:release] = lsb[:release]
               true
             end
-          }
-      plat.name('linuxmint').title('LinuxMint').in_family('debian')
-          .detect {
+          end
+      plat.name("linuxmint").title("LinuxMint").in_family("debian")
+          .detect do
             lsb = read_linux_lsb
             if lsb && lsb[:id] =~ /linuxmint/i
               @platform[:release] = lsb[:release]
               true
             end
-          }
-      plat.name('raspbian').title('Raspbian Linux').in_family('debian')
-          .detect {
-            if (linux_os_release && linux_os_release['NAME'] =~ /raspbian/i) || \
-               unix_file_exist?('/usr/bin/raspi-config')
-              @platform[:release] = unix_file_contents('/etc/debian_version').chomp
+          end
+      plat.name("raspbian").title("Raspbian Linux").in_family("debian")
+          .detect do
+            if (linux_os_release && linux_os_release["NAME"] =~ /raspbian/i) || \
+                unix_file_exist?("/usr/bin/raspi-config")
+              @platform[:release] = unix_file_contents("/etc/debian_version").chomp
               true
             end
-          }
-      plat.name('debian').title('Debian Linux').in_family('debian')
-          .detect {
+          end
+      plat.name("debian").title("Debian Linux").in_family("debian")
+          .detect do
             lsb = read_linux_lsb
             if lsb && lsb[:id] =~ /debian/i
               @platform[:release] = lsb[:release]
@@ -93,247 +93,247 @@ module Train::Platforms::Detect::Specifications
             end
 
             # if we get this far we have to be some type of debian
-            @platform[:release] = unix_file_contents('/etc/debian_version').chomp
+            @platform[:release] = unix_file_contents("/etc/debian_version").chomp
             true
-          }
+          end
 
       # fedora family
-      plat.family('fedora').in_family('linux')
-          .detect {
-            true if linux_os_release && linux_os_release['NAME'] =~ /fedora/i
-          }
-      plat.name('fedora').title('Fedora').in_family('fedora')
-          .detect {
-            @platform[:release] = linux_os_release['VERSION_ID']
+      plat.family("fedora").in_family("linux")
+          .detect do
+            true if linux_os_release && linux_os_release["NAME"] =~ /fedora/i
+          end
+      plat.name("fedora").title("Fedora").in_family("fedora")
+          .detect do
+            @platform[:release] = linux_os_release["VERSION_ID"]
             true
-          }
+          end
 
       # arista_eos family
       # this checks for the arista bash shell
       # must come before redhat as it uses fedora under the hood
-      plat.family('arista_eos').title('Arista EOS Family').in_family('linux')
-          .detect {
+      plat.family("arista_eos").title("Arista EOS Family").in_family("linux")
+          .detect do
             true
-          }
-      plat.name('arista_eos_bash').title('Arista EOS Bash Shell').in_family('arista_eos')
-          .detect {
-            if unix_file_exist?('/usr/bin/FastCli')
+          end
+      plat.name("arista_eos_bash").title("Arista EOS Bash Shell").in_family("arista_eos")
+          .detect do
+            if unix_file_exist?("/usr/bin/FastCli")
               cmd = @backend.run_command('FastCli -p 15 -c "show version | json"')
               if cmd.exit_status == 0 && !cmd.stdout.empty?
-                require 'json'
+                require "json"
                 begin
                   eos_ver = JSON.parse(cmd.stdout)
-                  @platform[:release] = eos_ver['version']
-                  @platform[:arch] = eos_ver['architecture']
+                  @platform[:release] = eos_ver["version"]
+                  @platform[:arch] = eos_ver["architecture"]
                   true
                 rescue JSON::ParserError
                   nil
                 end
               end
             end
-          }
+          end
 
       # redhat family
-      plat.family('redhat').in_family('linux')
-          .detect {
+      plat.family("redhat").in_family("linux")
+          .detect do
             # I am not sure this returns true for all redhats in this family
             # for now we are going to just try each platform
             # return true unless unix_file_contents('/etc/redhat-release').nil?
 
             true
-          }
-      plat.name('centos').title('Centos Linux').in_family('redhat')
-          .detect {
+          end
+      plat.name("centos").title("Centos Linux").in_family("redhat")
+          .detect do
             lsb = read_linux_lsb
             if lsb && lsb[:id] =~ /centos/i
               @platform[:release] = lsb[:release]
               true
-            elsif linux_os_release && linux_os_release['NAME'] =~ /centos/i
-              @platform[:release] = redhatish_version(unix_file_contents('/etc/redhat-release'))
+            elsif linux_os_release && linux_os_release["NAME"] =~ /centos/i
+              @platform[:release] = redhatish_version(unix_file_contents("/etc/redhat-release"))
               true
             end
-          }
-      plat.name('oracle').title('Oracle Linux').in_family('redhat')
-          .detect {
-            if !(raw = unix_file_contents('/etc/oracle-release')).nil?
+          end
+      plat.name("oracle").title("Oracle Linux").in_family("redhat")
+          .detect do
+            if !(raw = unix_file_contents("/etc/oracle-release")).nil?
               @platform[:release] = redhatish_version(raw)
               true
-            elsif !(raw = unix_file_contents('/etc/enterprise-release')).nil?
+            elsif !(raw = unix_file_contents("/etc/enterprise-release")).nil?
               @platform[:release] = redhatish_version(raw)
               true
             end
-          }
-      plat.name('scientific').title('Scientific Linux').in_family('redhat')
-          .detect {
+          end
+      plat.name("scientific").title("Scientific Linux").in_family("redhat")
+          .detect do
             lsb = read_linux_lsb
             if lsb && lsb[:id] =~ /scientific/i
               @platform[:release] = lsb[:release]
               true
             end
-          }
-      plat.name('xenserver').title('Xenserer Linux').in_family('redhat')
-          .detect {
+          end
+      plat.name("xenserver").title("Xenserer Linux").in_family("redhat")
+          .detect do
             lsb = read_linux_lsb
             if lsb && lsb[:id] =~ /xenserver/i
               @platform[:release] = lsb[:release]
               true
             end
-          }
-      plat.name('parallels-release').title('Parallels Linux').in_family('redhat')
-          .detect {
-            if !(raw = unix_file_contents('/etc/parallels-release')).nil?
+          end
+      plat.name("parallels-release").title("Parallels Linux").in_family("redhat")
+          .detect do
+            if !(raw = unix_file_contents("/etc/parallels-release")).nil?
               @platform[:name] = redhatish_platform(raw)
               @platform[:release] = raw[/(\d\.\d\.\d)/, 1]
               true
             end
-          }
-      plat.name('wrlinux').title('Wind River Linux').in_family('redhat')
-          .detect {
-            if linux_os_release && linux_os_release['ID_LIKE'] =~ /wrlinux/i
-              @platform[:release] = linux_os_release['VERSION']
+          end
+      plat.name("wrlinux").title("Wind River Linux").in_family("redhat")
+          .detect do
+            if linux_os_release && linux_os_release["ID_LIKE"] =~ /wrlinux/i
+              @platform[:release] = linux_os_release["VERSION"]
               true
             end
-          }
-      plat.name('amazon').title('Amazon Linux').in_family('redhat')
-          .detect {
+          end
+      plat.name("amazon").title("Amazon Linux").in_family("redhat")
+          .detect do
             lsb = read_linux_lsb
             if lsb && lsb[:id] =~ /amazon/i
               @platform[:release] = lsb[:release]
               true
-            elsif (raw = unix_file_contents('/etc/system-release')) =~ /amazon/i
+            elsif (raw = unix_file_contents("/etc/system-release")) =~ /amazon/i
               @platform[:name] = redhatish_platform(raw)
               @platform[:release] = redhatish_version(raw)
               true
             end
-          }
-      plat.name('cloudlinux').title('CloudLinux').in_family('redhat')
-          .detect {
+          end
+      plat.name("cloudlinux").title("CloudLinux").in_family("redhat")
+          .detect do
             lsb = read_linux_lsb
             if lsb && lsb[:id] =~ /cloudlinux/i
               @platform[:release] = lsb[:release]
               true
-            elsif (raw = unix_file_contents('/etc/redhat-release')) =~ /cloudlinux/i
+            elsif (raw = unix_file_contents("/etc/redhat-release")) =~ /cloudlinux/i
               @platform[:name] = redhatish_platform(raw)
               @platform[:release] = redhatish_version(raw)
               true
             end
-          }
+          end
       # keep redhat at the end as a fallback for anything with a redhat-release
-      plat.name('redhat').title('Red Hat Linux').in_family('redhat')
-          .detect {
+      plat.name("redhat").title("Red Hat Linux").in_family("redhat")
+          .detect do
             lsb = read_linux_lsb
             if lsb && lsb[:id] =~ /redhat/i
               @platform[:release] = lsb[:release]
               true
-            elsif !(raw = unix_file_contents('/etc/redhat-release')).nil?
+            elsif !(raw = unix_file_contents("/etc/redhat-release")).nil?
               # must be some type of redhat
               @platform[:name] = redhatish_platform(raw)
               @platform[:release] = redhatish_version(raw)
               true
             end
-          }
+          end
 
       # suse family
-      plat.family('suse').in_family('linux')
-          .detect {
-            if !(suse = unix_file_contents('/etc/SuSE-release')).nil?
+      plat.family("suse").in_family("linux")
+          .detect do
+            if !(suse = unix_file_contents("/etc/SuSE-release")).nil?
               # https://rubular.com/r/UKaYWolCYFMfp1
-              version = suse.scan(/VERSION = (\d+)\nPATCHLEVEL = (\d+)/).flatten.join('.')
+              version = suse.scan(/VERSION = (\d+)\nPATCHLEVEL = (\d+)/).flatten.join(".")
               # https://rubular.com/r/b5PN3hZDxa5amV
-              version = suse[/VERSION\s?=\s?"?([\d\.]{2,})"?/, 1] if version == ''
+              version = suse[/VERSION\s?=\s?"?([\d\.]{2,})"?/, 1] if version == ""
               @platform[:release] = version
               true
             end
-          }
-      plat.name('opensuse').title('OpenSUSE Linux').in_family('suse')
-          .detect {
-            true if unix_file_contents('/etc/SuSE-release') =~ /^opensuse/i
-          }
-      plat.name('suse').title('Suse Linux').in_family('suse')
-          .detect {
-            true if unix_file_contents('/etc/SuSE-release') =~ /suse/i
-          }
+          end
+      plat.name("opensuse").title("OpenSUSE Linux").in_family("suse")
+          .detect do
+            true if unix_file_contents("/etc/SuSE-release") =~ /^opensuse/i
+          end
+      plat.name("suse").title("Suse Linux").in_family("suse")
+          .detect do
+            true if unix_file_contents("/etc/SuSE-release") =~ /suse/i
+          end
 
       # arch
-      plat.name('arch').title('Arch Linux').in_family('linux')
-          .detect {
-            if !unix_file_contents('/etc/arch-release').nil?
+      plat.name("arch").title("Arch Linux").in_family("linux")
+          .detect do
+            if !unix_file_contents("/etc/arch-release").nil?
               # Because this is a rolling release distribution,
               # use the kernel release, ex. 4.1.6-1-ARCH
               @platform[:release] = unix_uname_r
               true
             end
-          }
+          end
 
       # slackware
-      plat.name('slackware').title('Slackware Linux').in_family('linux')
-          .detect {
-            if !(raw = unix_file_contents('/etc/slackware-version')).nil?
+      plat.name("slackware").title("Slackware Linux").in_family("linux")
+          .detect do
+            if !(raw = unix_file_contents("/etc/slackware-version")).nil?
               @platform[:release] = raw.scan(/(\d+|\.+)/).join
               true
             end
-          }
+          end
 
       # gentoo
-      plat.name('gentoo').title('Gentoo Linux').in_family('linux')
-          .detect {
-            if !(raw = unix_file_contents('/etc/gentoo-release')).nil?
+      plat.name("gentoo").title("Gentoo Linux").in_family("linux")
+          .detect do
+            if !(raw = unix_file_contents("/etc/gentoo-release")).nil?
               @platform[:release] = raw.scan(/(\d+|\.+)/).join
               true
             end
-          }
+          end
 
       # exherbo
-      plat.name('exherbo').title('Exherbo Linux').in_family('linux')
-          .detect {
-            unless unix_file_contents('/etc/exherbo-release').nil?
+      plat.name("exherbo").title("Exherbo Linux").in_family("linux")
+          .detect do
+            unless unix_file_contents("/etc/exherbo-release").nil?
               # Because this is a rolling release distribution,
               # use the kernel release, ex. 4.1.6
               @platform[:release] = unix_uname_r
               true
             end
-          }
+          end
 
       # alpine
-      plat.name('alpine').title('Alpine Linux').in_family('linux')
-          .detect {
-            if !(raw = unix_file_contents('/etc/alpine-release')).nil?
+      plat.name("alpine").title("Alpine Linux").in_family("linux")
+          .detect do
+            if !(raw = unix_file_contents("/etc/alpine-release")).nil?
               @platform[:release] = raw.strip
               true
             end
-          }
+          end
 
       # coreos
-      plat.name('coreos').title('CoreOS Linux').in_family('linux')
-          .detect {
-            unless unix_file_contents('/etc/coreos/update.conf').nil?
+      plat.name("coreos").title("CoreOS Linux").in_family("linux")
+          .detect do
+            unless unix_file_contents("/etc/coreos/update.conf").nil?
               lsb = read_linux_lsb
               @platform[:release] = lsb[:release]
               true
             end
-          }
+          end
 
       # brocade family detected here if device responds to 'uname' command,
       # happens when logging in as root
-      plat.family('brocade').title('Brocade Family').in_family('linux')
-          .detect {
+      plat.family("brocade").title("Brocade Family").in_family("linux")
+          .detect do
             !brocade_version.nil?
-          }
+          end
 
       # genaric linux
       # this should always be last in the linux family list
-      plat.name('linux').title('Genaric Linux').in_family('linux')
-          .detect {
+      plat.name("linux").title("Genaric Linux").in_family("linux")
+          .detect do
             true
-          }
+          end
 
       # openvms
-      plat.name('openvms').title('OpenVMS').in_family('unix')
-          .detect {
+      plat.name("openvms").title("OpenVMS").in_family("unix")
+          .detect do
             if unix_uname_s =~ /unrecognized command verb/i
-              cmd = @backend.run_command('show system/noprocess')
+              cmd = @backend.run_command("show system/noprocess")
               unless cmd.exit_status != 0 || cmd.stdout.empty?
-                @platform[:name] = cmd.stdout.downcase.split(' ')[0]
+                @platform[:name] = cmd.stdout.downcase.split(" ")[0]
                 cmd = @backend.run_command('write sys$output f$getsyi("VERSION")')
                 @platform[:release] = cmd.stdout.downcase.split("\n")[1][1..-1]
                 cmd = @backend.run_command('write sys$output f$getsyi("ARCH_NAME")')
@@ -341,78 +341,78 @@ module Train::Platforms::Detect::Specifications
                 true
               end
             end
-          }
+          end
 
       # aix
-      plat.family('aix').in_family('unix')
-          .detect {
+      plat.family("aix").in_family("unix")
+          .detect do
             true if unix_uname_s =~ /aix/i
-          }
-      plat.name('aix').title('Aix').in_family('aix')
-          .detect {
-            out = @backend.run_command('uname -rvp').stdout
+          end
+      plat.name("aix").title("Aix").in_family("aix")
+          .detect do
+            out = @backend.run_command("uname -rvp").stdout
             m = out.match(/(\d+)\s+(\d+)\s+(.*)/)
             unless m.nil?
               @platform[:release] = "#{m[2]}.#{m[1]}"
               @platform[:arch] = m[3].to_s
             end
             true
-          }
+          end
 
       # solaris family
-      plat.family('solaris').in_family('unix')
-          .detect {
+      plat.family("solaris").in_family("unix")
+          .detect do
             if unix_uname_s =~ /sunos/i
               unless (version = /^5\.(?<release>\d+)$/.match(unix_uname_r)).nil?
-                @platform[:release] = version['release']
+                @platform[:release] = version["release"]
               end
 
-              arch = @backend.run_command('uname -p')
+              arch = @backend.run_command("uname -p")
               @platform[:arch] = arch.stdout.chomp if arch.exit_status == 0
               true
             end
-          }
-      plat.name('smartos').title('SmartOS').in_family('solaris')
-          .detect {
-            rel = unix_file_contents('/etc/release')
+          end
+      plat.name("smartos").title("SmartOS").in_family("solaris")
+          .detect do
+            rel = unix_file_contents("/etc/release")
             if /^.*(SmartOS).*$/ =~ rel
               true
             end
-          }
-      plat.name('omnios').title('Omnios').in_family('solaris')
-          .detect {
-            rel = unix_file_contents('/etc/release')
+          end
+      plat.name("omnios").title("Omnios").in_family("solaris")
+          .detect do
+            rel = unix_file_contents("/etc/release")
             if !(m = /^\s*(OmniOS).*r(\d+).*$/.match(rel)).nil?
               @platform[:release] = m[2]
               true
             end
-          }
-      plat.name('openindiana').title('Openindiana').in_family('solaris')
-          .detect {
-            rel = unix_file_contents('/etc/release')
+          end
+      plat.name("openindiana").title("Openindiana").in_family("solaris")
+          .detect do
+            rel = unix_file_contents("/etc/release")
             if !(m = /^\s*(OpenIndiana).*oi_(\d+).*$/.match(rel)).nil?
               @platform[:release] = m[2]
               true
             end
-          }
-      plat.name('opensolaris').title('Open Solaris').in_family('solaris')
-          .detect {
-            rel = unix_file_contents('/etc/release')
+          end
+      plat.name("opensolaris").title("Open Solaris").in_family("solaris")
+          .detect do
+            rel = unix_file_contents("/etc/release")
             if !(m = /^\s*(OpenSolaris).*snv_(\d+).*$/.match(rel)).nil?
               @platform[:release] = m[2]
               true
             end
-          }
-      plat.name('nexentacore').title('Nexentacore').in_family('solaris')
-          .detect {
-            rel = unix_file_contents('/etc/release')
+          end
+      plat.name("nexentacore").title("Nexentacore").in_family("solaris")
+          .detect do
+            rel = unix_file_contents("/etc/release")
             if /^\s*(NexentaCore)\s.*$/ =~ rel
               true
             end
-          }
-      plat.name('solaris').title('Solaris').in_family('solaris')
-          .detect {
-            rel = unix_file_contents('/etc/release')
+          end
+      plat.name("solaris").title("Solaris").in_family("solaris")
+          .detect do
+            rel = unix_file_contents("/etc/release")
             if !(m = /Oracle Solaris (\d+)/.match(rel)).nil?
               # TODO: should be string!
               @platform[:release] = m[1]
@@ -423,43 +423,43 @@ module Train::Platforms::Detect::Specifications
 
             # must be some unknown solaris
             true
-          }
+          end
 
       # hpux
-      plat.family('hpux').in_family('unix')
-          .detect {
+      plat.family("hpux").in_family("unix")
+          .detect do
             true if unix_uname_s =~ /hp-ux/i
-          }
-      plat.name('hpux').title('Hpux').in_family('hpux')
-          .detect {
+          end
+      plat.name("hpux").title("Hpux").in_family("hpux")
+          .detect do
             @platform[:release] = unix_uname_r.lines[0].chomp
             true
-          }
+          end
 
       # qnx
-      plat.family('qnx').in_family('unix')
-          .detect {
+      plat.family("qnx").in_family("unix")
+          .detect do
             true if unix_uname_s =~ /qnx/i
-          }
-      plat.name('qnx').title('QNX').in_family('qnx')
-          .detect {
+          end
+      plat.name("qnx").title("QNX").in_family("qnx")
+          .detect do
             @platform[:name] = unix_uname_s.lines[0].chomp.downcase
             @platform[:release] = unix_uname_r.lines[0].chomp
             @platform[:arch] = unix_uname_m
             true
-          }
+          end
 
       # bsd family
-      plat.family('bsd').in_family('unix')
-          .detect {
+      plat.family("bsd").in_family("unix")
+          .detect do
             # we need a better way to determin this family
             # for now we are going to just try each platform
             true
-          }
-      plat.family('darwin').in_family('bsd')
-          .detect {
+          end
+      plat.family("darwin").in_family("bsd")
+          .detect do
             if unix_uname_s =~ /darwin/i
-              cmd = unix_file_contents('/usr/bin/sw_vers')
+              cmd = unix_file_contents("/usr/bin/sw_vers")
               unless cmd.nil?
                 m = cmd.match(/^ProductVersion:\s+(.+)$/)
                 @platform[:release] = m.nil? ? nil : m[1]
@@ -470,122 +470,122 @@ module Train::Platforms::Detect::Specifications
               @platform[:arch] = unix_uname_m
               true
             end
-          }
-      plat.name('mac_os_x').title('macOS X').in_family('darwin')
-          .detect {
-            cmd = unix_file_contents('/System/Library/CoreServices/SystemVersion.plist')
+          end
+      plat.name("mac_os_x").title("macOS X").in_family("darwin")
+          .detect do
+            cmd = unix_file_contents("/System/Library/CoreServices/SystemVersion.plist")
             @platform[:uuid_command] = "system_profiler SPHardwareDataType | awk '/UUID/ { print $3; }'"
             true if cmd =~ /Mac OS X/i
-          }
-      plat.name('darwin').title('Darwin').in_family('darwin')
-          .detect {
+          end
+      plat.name("darwin").title("Darwin").in_family("darwin")
+          .detect do
             # must be some other type of darwin
             @platform[:name] = unix_uname_s.lines[0].chomp
             true
-          }
-      plat.name('freebsd').title('Freebsd').in_family('bsd')
-          .detect {
+          end
+      plat.name("freebsd").title("Freebsd").in_family("bsd")
+          .detect do
             if unix_uname_s =~ /freebsd/i
               @platform[:name] = unix_uname_s.lines[0].chomp
               @platform[:release] = unix_uname_r.lines[0].chomp
               true
             end
-          }
-      plat.name('openbsd').title('Openbsd').in_family('bsd')
-          .detect {
+          end
+      plat.name("openbsd").title("Openbsd").in_family("bsd")
+          .detect do
             if unix_uname_s =~ /openbsd/i
               @platform[:name] = unix_uname_s.lines[0].chomp
               @platform[:release] = unix_uname_r.lines[0].chomp
               true
             end
-          }
-      plat.name('netbsd').title('Netbsd').in_family('bsd')
-          .detect {
+          end
+      plat.name("netbsd").title("Netbsd").in_family("bsd")
+          .detect do
             if unix_uname_s =~ /netbsd/i
               @platform[:name] = unix_uname_s.lines[0].chomp
               @platform[:release] = unix_uname_r.lines[0].chomp
               true
             end
-          }
+          end
 
       # arista_eos family
-      plat.family('arista_eos').title('Arista EOS Family').in_family('os')
-          .detect {
+      plat.family("arista_eos").title("Arista EOS Family").in_family("os")
+          .detect do
             true
-          }
-      plat.name('arista_eos').title('Arista EOS').in_family('arista_eos')
-          .detect {
-            cmd = @backend.run_command('show version | json')
+          end
+      plat.name("arista_eos").title("Arista EOS").in_family("arista_eos")
+          .detect do
+            cmd = @backend.run_command("show version | json")
             if cmd.exit_status == 0 && !cmd.stdout.empty?
-              require 'json'
+              require "json"
               begin
                 eos_ver = JSON.parse(cmd.stdout)
-                @platform[:release] = eos_ver['version']
-                @platform[:arch] = eos_ver['architecture']
+                @platform[:release] = eos_ver["version"]
+                @platform[:arch] = eos_ver["architecture"]
                 true
               rescue JSON::ParserError
                 nil
               end
             end
-          }
+          end
 
       # esx
-      plat.family('esx').title('ESXi Family').in_family('os')
-          .detect {
+      plat.family("esx").title("ESXi Family").in_family("os")
+          .detect do
             true if unix_uname_s =~ /vmkernel/i
-          }
-      plat.name('vmkernel').in_family('esx')
-          .detect {
+          end
+      plat.name("vmkernel").in_family("esx")
+          .detect do
             @platform[:name] = unix_uname_s.lines[0].chomp
             @platform[:release] = unix_uname_r.lines[0].chomp
             true
-          }
+          end
 
       # cisco_ios family
-      plat.family('cisco').title('Cisco Family').in_family('os')
-          .detect {
+      plat.family("cisco").title("Cisco Family").in_family("os")
+          .detect do
             !cisco_show_version.nil?
-          }
-      plat.name('cisco_ios').title('Cisco IOS').in_family('cisco')
-          .detect {
+          end
+      plat.name("cisco_ios").title("Cisco IOS").in_family("cisco")
+          .detect do
             v = cisco_show_version
-            next unless v[:type] == 'ios'
+            next unless v[:type] == "ios"
             @platform[:release] = v[:version]
             @platform[:arch] = nil
             true
-          }
-      plat.name('cisco_ios_xe').title('Cisco IOS XE').in_family('cisco')
-          .detect {
+          end
+      plat.name("cisco_ios_xe").title("Cisco IOS XE").in_family("cisco")
+          .detect do
             v = cisco_show_version
-            next unless v[:type] == 'ios-xe'
+            next unless v[:type] == "ios-xe"
             @platform[:release] = v[:version]
             @platform[:arch] = nil
             true
-          }
-      plat.name('cisco_nexus').title('Cisco Nexus').in_family('cisco')
-          .detect {
+          end
+      plat.name("cisco_nexus").title("Cisco Nexus").in_family("cisco")
+          .detect do
             v = cisco_show_version
-            next unless v[:type] == 'nexus'
+            next unless v[:type] == "nexus"
             @platform[:release] = v[:version]
             @platform[:arch] = nil
-            @platform[:uuid_command] = 'show version | include Processor'
+            @platform[:uuid_command] = "show version | include Processor"
             true
-          }
+          end
 
       # brocade family
-      plat.family('brocade').title('Brocade Family').in_family('os')
-          .detect {
+      plat.family("brocade").title("Brocade Family").in_family("os")
+          .detect do
             !brocade_version.nil?
-          }
+          end
 
-      plat.name('brocade_fos').title('Brocade FOS').in_family('brocade')
-          .detect {
+      plat.name("brocade_fos").title("Brocade FOS").in_family("brocade")
+          .detect do
             v = brocade_version
-            next unless v[:type] == 'fos'
+            next unless v[:type] == "fos"
             @platform[:release] = v[:version]
             @platform[:arch] = nil
             true
-          }
+          end
     end
   end
 end