Rubocop autocorrect

Author: DavidS

lib/facter/logical_volumes.rb

@@ -2,7 +2,7 @@
   # Fact should be confined to only linux servers that have the lvs command
   confine do
     Facter.value('kernel') == 'Linux' &&
-    Facter::Core::Execution.which('lvs')
+      Facter::Core::Execution.which('lvs')
   end
 
   setcode do
@@ -29,4 +29,4 @@
     output = Facter::Core::Execution.exec("lvs -o #{columns.join(',')}  --noheading --nosuffix")
     Puppet_X::LVM::Output.parse('lv_name', columns, output)
   end
-end
+end

lib/facter/lvm_support.rb

@@ -1,7 +1,7 @@
 # lvm_support: true/nil
 #   Whether there is LVM support (based on the presence of the "vgs" command)
 Facter.add('lvm_support') do
-  confine :kernel => :linux
+  confine kernel: :linux
 
   setcode do
     vgdisplay = Facter::Util::Resolution.which('vgs')
@@ -13,12 +13,12 @@
 #   Number of VGs
 vg_list = []
 Facter.add('lvm_vgs') do
-  confine :lvm_support => true
+  confine lvm_support: true
 
   if Facter.value(:lvm_support)
     vgs = Facter::Core::Execution.execute('vgs -o name --noheadings 2>/dev/null', timeout: 30)
   end
-  
+
   if vgs.nil?
     setcode { 0 }
   else
@@ -36,7 +36,7 @@
       pvs = Facter::Core::Execution.execute("vgs -o pv_name #{vg} 2>/dev/null", timeout: 30)
       res = nil
       unless pvs.nil?
-        res = pvs.split("\n").select{|l| l =~ /^\s+\// }.collect(&:strip).sort.join(',')
+        res = pvs.split("\n").select { |l| l =~ /^\s+\// }.map(&:strip).sort.join(',')
       end
       res
     end
@@ -47,7 +47,7 @@
 #   Number of PVs
 pv_list = []
 Facter.add('lvm_pvs') do
-  confine :lvm_support => true
+  confine lvm_support: true
   if Facter.value(:lvm_support)
     pvs = Facter::Core::Execution.execute('pvs -o name --noheadings 2>/dev/null', timeout: 30)
   end

lib/facter/physical_volumes.rb

@@ -2,7 +2,7 @@
   # Fact should be confined to only linux servers that have the lvs command
   confine do
     Facter.value('kernel') == 'Linux' &&
-    Facter::Core::Execution.which('pvs')
+      Facter::Core::Execution.which('pvs')
   end
 
   setcode do

lib/facter/volume_groups.rb

@@ -2,7 +2,7 @@
   # Fact should be confined to only linux servers that have the lvs command
   confine do
     Facter.value('kernel') == 'Linux' &&
-    Facter::Core::Execution.which('vgs')
+      Facter::Core::Execution.which('vgs')
   end
 
   setcode do
@@ -25,4 +25,4 @@
     output = Facter::Core::Execution.exec("vgs -o #{columns.join(',')}  --noheading --nosuffix")
     Puppet_X::LVM::Output.parse('vg_name', columns, output)
   end
-end
+end

lib/puppet/provider/filesystem/aix.rb

@@ -1,13 +1,12 @@
 require 'open3'
 Puppet::Type.type(:filesystem).provide :aix do
+  desc 'Manages logical volume filesystems on AIX'
 
-  desc "Manages logical volume filesystems on AIX"
+  confine operatingsystem: :AIX
+  defaultfor operatingsystem: :AIX
 
-  confine :operatingsystem => :AIX
-  defaultfor :operatingsystem => :AIX
-
-  commands :crfs => 'crfs',
-           :chfs => 'chfs'
+  commands crfs: 'crfs',
+           chfs: 'chfs'
 
   def exists?
     Open3.popen3("lsfs #{@resource[:name]}")[3].value.success?
@@ -16,7 +15,7 @@ def exists?
   def create
     args = []
 
-    attributes=[
+    attributes = [
       :ag_size,
       :large_files,
       :compress,
@@ -33,7 +32,7 @@ def create
       :agblksize,
       :extended_attributes,
       :mount_options,
-      :vix
+      :vix,
     ]
 
     args.push(*add_attributes(*attributes))
@@ -52,37 +51,37 @@ def create
     # size property after creation
     if @resource[:size]
       if size != @resource[:size]
-        self.size= (@resource[:size])
+        self.size = (@resource[:size])
       end
     end
   end
 
   def attribute_flag(pvalue)
     {
-      :ag_size              => 'ag',
-      :large_file           => 'bf',
-      :initial_size         => 'size',
-      :size                 => 'size',
-      :extended_attributes  => 'ea',
-      :mount_options        => 'options',
-      :encrypted            => 'efs'
+      ag_size: 'ag',
+      large_file: 'bf',
+      initial_size: 'size',
+      size: 'size',
+      extended_attributes: 'ea',
+      mount_options: 'options',
+      encrypted: 'efs',
     }[pvalue] || pvalue.to_s
   end
 
   def add_attributes(*args)
-    attr_args=[]
+    attr_args = []
     args.each do |arg|
       if @resource[arg]
-        ans=parse_boolean(@resource[arg])
+        ans = parse_boolean(@resource[arg])
         attr_args.push('-a', "#{attribute_flag(arg)}=#{@resource[arg]}")
       end
     end
     attr_args
   end
 
-  def add_flag(flag,param)
+  def add_flag(flag, param)
     if @resource[param]
-      [ "-#{flag.to_s}", "#{parse_boolean(@resource[param])}" ]
+      ["-#{flag}", parse_boolean(@resource[param]).to_s]
     end
   end
 
@@ -98,71 +97,71 @@ def parse_boolean(param)
   end
 
   def size
-    cursize=0
-    reqsize=blk_roundup(val_to_blk(@resource[:size]))
+    cursize = 0
+    reqsize = blk_roundup(val_to_blk(@resource[:size]))
 
-    Open3.popen3("lsfs -q #{@resource[:name]}") do |stdin, stdout, stderr|
+    Open3.popen3("lsfs -q #{@resource[:name]}") do |_stdin, stdout, _stderr|
       stdout.each do |line|
-        elements=line.split(/\s+/)
+        elements = line.split(%r{\s+})
         if elements[2] == @resource[:name]
-          cursize=elements[4].to_i
+          cursize = elements[4].to_i
         end
       end
     end
 
     if cursize == reqsize
       @resource[:size]
     else
-      blk_to_val(cursize,@resource[:size][-1,1])
+      blk_to_val(cursize, @resource[:size][-1, 1])
     end
   end
 
-  def size=(newsize)
-    chfs('-a',"size=#{@resource[:size]}", @resource[:name])
+  def size=(_newsize)
+    chfs('-a', "size=#{@resource[:size]}", @resource[:name])
   end
 
   def val_to_blk(val)
-    input = val.match(/(\d+)([^0-9]|)/).to_a
+    input = val.match(%r{(\d+)([^0-9]|)}).to_a
     case input[2]
     when 'M'
-      input[1].to_i*1024*2
+      input[1].to_i * 1024 * 2
     when 'G'
-      input[1].to_i*1024*1024*2
+      input[1].to_i * 1024 * 1024 * 2
     else
       input[1].to_i
     end
   end
 
-  def blk_to_val(blocks,units=nil)
+  def blk_to_val(blocks, units = nil)
     case units
     when 'M'
-      sprintf('%gM', Float(blocks.to_i/2/1024))
+      '%gM' % Float(blocks.to_i / 2 / 1024)
     when 'G'
-      sprintf('%gG', Float(blocks.to_i/2/1024/1024))
+      '%gG' % Float(blocks.to_i / 2 / 1024 / 1024)
     else
       blocks
     end
   end
 
   def blk_roundup(blocks)
-    ppsize=Integer(pp_size*1024*2)
-    ppsize*Float(Float(blocks)/ppsize).ceil.to_i
+    ppsize = Integer(pp_size * 1024 * 2)
+    ppsize * Float(Float(blocks) / ppsize).ceil.to_i
   end
 
   def pp_size
     vg = @resource[:volume_group] || 'rootvg'
-    Open3.capture2("lsvg #{vg} | /bin/grep 'PP SIZE'")[0].split(/\s+/)[5].to_i
+    Open3.capture2("lsvg #{vg} | /bin/grep 'PP SIZE'")[0].split(%r{\s+})[5].to_i
   end
 
   def attribute_flag(pvalue)
     {
-      :ag_size              => 'ag',
-      :large_file           => 'bf',
-      :initial_size         => 'size',
-      :size                 => 'size',
-      :extended_attributes  => 'ea',
-      :mount_options        => 'options',
-      :encrypted            => 'efs'
+      ag_size: 'ag',
+      large_file: 'bf',
+      initial_size: 'size',
+      size: 'size',
+      extended_attributes: 'ea',
+      mount_options: 'options',
+      encrypted: 'efs',
     }[pvalue] || pvalue.to_s
   end
 end

lib/puppet/provider/filesystem/lvm.rb

@@ -1,57 +1,56 @@
 Puppet::Type.type(:filesystem).provide :lvm do
-    desc "Manages filesystem of a logical volume on Linux"
+  desc 'Manages filesystem of a logical volume on Linux'
 
-    confine :kernel => :linux
+  confine kernel: :linux
 
-    commands :blkid => 'blkid'
+  commands blkid: 'blkid'
 
-    def create
-        mkfs(@resource[:fs_type], @resource[:name])
-    end
+  def create
+    mkfs(@resource[:fs_type], @resource[:name])
+  end
 
-    def exists?
-        fstype == @resource[:fs_type]
-    end
+  def exists?
+    fstype == @resource[:fs_type]
+  end
 
-    def destroy
-        # no-op
-    end
+  def destroy
+    # no-op
+  end
+
+  def fstype
+    %r{\bTYPE=\"(\S+)\"}.match(blkid(@resource[:name]))[1]
+  rescue Puppet::ExecutionFailure
+    nil
+  end
 
-    def fstype
-        /\bTYPE=\"(\S+)\"/.match(blkid(@resource[:name]))[1]
-    rescue Puppet::ExecutionFailure
-        nil
+  def mkfs(fs_type, name)
+    mkfs_params = { 'reiserfs' => '-q', 'xfs' => '-f' }
+
+    mkfs_cmd = !@resource[:mkfs_cmd].nil? ?
+                 [@resource[:mkfs_cmd]] :
+               case fs_type
+               when 'swap'
+                 ['mkswap']
+               else
+                 ["mkfs.#{fs_type}"]
+               end
+
+    mkfs_cmd << name
+
+    if mkfs_params[fs_type]
+      mkfs_cmd << mkfs_params[fs_type]
     end
 
-    def mkfs(fs_type, name)
-        mkfs_params = { "reiserfs" => "-q"  , "xfs" => "-f" }
-
-        mkfs_cmd = @resource[:mkfs_cmd] != nil ?
-                     [@resource[:mkfs_cmd]] :
-                   case fs_type
-                   when 'swap'
-                     ["mkswap"]
-                   else
-                     ["mkfs.#{fs_type}"]
-                   end
-       
-        mkfs_cmd << name
-
-        if mkfs_params[fs_type]
-            mkfs_cmd << mkfs_params[fs_type]
-        end
-        
-        if resource[:options]
-            mkfs_options = Array.new(resource[:options].split)
-            mkfs_cmd << mkfs_options
-        end
-
-        execute mkfs_cmd
-        if fs_type == 'swap'
-            swap_cmd = ["swapon"]
-            swap_cmd << name
-            execute swap_cmd
-        end
+    if resource[:options]
+      mkfs_options = Array.new(resource[:options].split)
+      mkfs_cmd << mkfs_options
     end
 
+    execute mkfs_cmd
+    if fs_type == 'swap'
+      swap_cmd = ['swapon']
+      swap_cmd << name
+      execute swap_cmd
+    end
+  end
 end