moose-inventory 1.0.7 → 1.0.9

data/lib/moose_inventory/cli/formatter.rb

@@ -15,37 +15,37 @@ module Moose
         def self.dump(arg, format = nil)
           out(arg, format)
         end
-        
+
         def self.out(arg, format = nil)
           return if arg.nil?
 
           if format.nil?
             format = Moose::Inventory::Config._confopts[:format].downcase
           end
-          
+
           case format
-          when 'yaml','y'
+          when 'yaml', 'y'
             $stdout.puts arg.to_yaml
 
-          when 'prettyjson','pjson','p'
+          when 'prettyjson', 'pjson', 'p'
             $stdout.puts JSON.pretty_generate(arg)
 
-          when 'json','j'
+          when 'json', 'j'
             $stdout.puts arg.to_json
 
           else
             abort("Output format '#{format}' is not yet supported.")
           end
         end
-        
+
         #---------------
         attr_accessor :indent
 
         def reset_indent
           @indent = 2
         end
-        
-        def puts(indent, msg, stream='STDOUT')
+
+        def puts(indent, msg, stream = 'STDOUT')
           case stream
           when 'STDOUT'
             $stdout.puts msg.indent(indent)
@@ -55,8 +55,8 @@ module Moose
             abort("Output stream '#{stream}' is not known.")
           end
         end
-        
-        def print(indent, msg, stream='STDOUT')
+
+        def print(indent, msg, stream = 'STDOUT')
           case stream
           when 'STDOUT'
             $stdout.print msg.indent(indent)
@@ -67,25 +67,24 @@ module Moose
           end
         end
 
-        def info(indent, msg, stream='STDOUT')
+        def info(_indent, _msg, stream = 'STDOUT')
           case stream
           when 'STDOUT'
-            $stdout.print "INFO: {msg}"
+            $stdout.print 'INFO: {msg}'
           when 'STDERR'
-            $stderr.print "INFO: {msg}"
+            $stderr.print 'INFO: {msg}'
           else
             abort("Output stream '#{stream}' is not known.")
           end
         end
-        
+
         def warn(msg)
-            $stderr.print "WARNING: #{msg}"
+          $stderr.print "WARNING: #{msg}"
         end
 
         def error(msg)
-            $stderr.print "ERROR: #{msg}"
+          $stderr.print "ERROR: #{msg}"
         end
-                        
       end
     end
   end

data/lib/moose_inventory/cli/group.rb

@@ -6,7 +6,7 @@ module Moose
     module Cli
       ##
       # Class implementing the "group" methods of the CLI
-      class Group < Thor 
+      class Group < Thor
         require_relative 'group_add'
         require_relative 'group_get'
         require_relative 'group_list'

data/lib/moose_inventory/cli/group_add.rb

@@ -13,7 +13,7 @@ module Moose
         # rubocop:disable Metrics/LineLength
         def add(*argv) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
           # rubocop:enable Metrics/LineLength
-          if argv.length < 1
+          if argv.empty?
             abort("ERROR: Wrong number of arguments, #{argv.length} for 1 or more.")
           end
 
@@ -27,10 +27,10 @@ module Moose
             abort("ERROR: Cannot manually manipulate the automatic group 'ungrouped'\n")
           end
 
-            # Convenience
-            db    = Moose::Inventory::DB
-            fmt = Moose::Inventory::Cli::Formatter
-          
+          # Convenience
+          db = Moose::Inventory::DB
+          fmt = Moose::Inventory::Cli::Formatter
+
           # Transaction
           warn_count = 0
           db.transaction do # Transaction start
@@ -39,48 +39,47 @@ module Moose
               puts "Add group '#{name}':"
               group = db.models[:group].find(name: name)
               hosts_ds = nil
-              fmt.puts 2, "- create group..."
+              fmt.puts 2, '- create group...'
               if group.nil?
                 group = db.models[:group].create(name: name)
                 fmt.puts 4, '- OK'
               else
                 warn_count += 1
                 fmt.warn "Group '#{name}' already exists, skipping creation.\n"
-                fmt.puts 4, "- already exists, skipping."
+                fmt.puts 4, '- already exists, skipping.'
                 hosts_ds = group.hosts_dataset
                 fmt.puts 4, '- OK'
               end
-              
+
               # Associate with hosts
               hosts.each do |h|
                 next if h.nil? || h.empty?
-                fmt.puts 2, "- add association {group:#{name} <-> host:#{ h }}..."
+                fmt.puts 2, "- add association {group:#{name} <-> host:#{h}}..."
                 host = db.models[:host].find(name: h)
                 if host.nil?
                   warn_count += 1
                   fmt.warn "Host '#{h}' doesn't exist, but will be created.\n"
                   fmt.puts 4, "- host doesn't exist, creating now..."
                   host = db.models[:host].create(name: h)
-                  fmt.puts 6, "- OK"
+                  fmt.puts 6, '- OK'
                 end
                 if !hosts_ds.nil? && !hosts_ds[name: h].nil?
                   warn_count += 1
-                  fmt.warn "Association {group:#{name} <-> host:#{ h }}"\
+                  fmt.warn "Association {group:#{name} <-> host:#{h}}"\
                     " already exists, skipping creation.\n"
-                    fmt.puts 4, "- already exists, skipping."
-                else  
+                  fmt.puts 4, '- already exists, skipping.'
+                else
                   group.add_host(host)
                 end
                 fmt.puts 4, '- OK'
-  
+
                 # Handle the host's automatic 'ungrouped' group
                 ungrouped = host.groups_dataset[name: 'ungrouped']
-                unless ungrouped.nil?
-                  fmt.puts 2, "- remove automatic association {group:ungrouped"\
-                    " <-> host:#{ h }}..."
-                  host.remove_group( ungrouped ) unless ungrouped.nil?
-                  fmt.puts 4, '- OK'
-                end
+                next if ungrouped.nil?
+                fmt.puts 2, '- remove automatic association {group:ungrouped'\
+                  " <-> host:#{h}}..."
+                host.remove_group(ungrouped) unless ungrouped.nil?
+                fmt.puts 4, '- OK'
               end
               fmt.puts 2, '- all OK'
             end
@@ -95,4 +94,3 @@ module Moose
     end
   end
 end
-

data/lib/moose_inventory/cli/group_addchild.rb

@@ -6,34 +6,33 @@ module Moose
     module Cli
       ##
       # Implemention of the "group addchild" methods of the CLI
-      class Group < Thor # rubocop:disable ClassLength
+      class Group < Thor
         #==========================
         desc 'addchild PARENTGROUP CHILDGROUP_1 [CHILDGROUP_2 ... ]',
              'Associate one or more child-groups CHILDGROUP_n with PARENTGROUP'
-        def addchild(*argv)
-          
+        def addchild(*_argv)
           # Sanity check
           if args.length < 2
             abort("ERROR: Wrong number of arguments, #{args.length} "\
-              "for 2 or more.")
+              'for 2 or more.')
           end
-          
+
           # Arguments
           pname = args[0].downcase
           cnames = args.slice(1, args.length - 1).uniq.map(&:downcase)
-           
+
           # Sanity
           if pname == 'ungrouped' || cnames.include?('ungrouped')
             abort("ERROR: Cannot manually manipulate the automatic group 'ungrouped'.")
           end
-          
+
           # Convenience
           db = Moose::Inventory::DB
           fmt = Moose::Inventory::Cli::Formatter
 
           # Transaction
           warn_count = 0
-          begin 
+          begin
             db.transaction do # Transaction start
               puts "Associate parent group '#{pname}' with child group(s) '#{cnames.join(',')}':"
               # Get the target group
@@ -42,51 +41,48 @@ module Moose
               if pgroup.nil?
                 abort("ERROR: The group '#{pname}' does not exist.")
               end
-              fmt.puts 4, "- OK"
-              
-               # Associate parent group with the child groups
+              fmt.puts 4, '- OK'
+
+              # Associate parent group with the child groups
+
+              groups_ds = pgroup.children_dataset
+              cnames.each do |cname|
+                fmt.puts 2, "- add association {group:#{pname} <-> group:#{cname}}..."
 
-               groups_ds = pgroup.children_dataset
-               cnames.each do |cname|
-                 fmt.puts 2, "- add association {group:#{pname} <-> group:#{cname}}..."
-                  
-                 # Check against existing associations
-                 unless groups_ds[name: cname].nil?
-                    warn_count += 1
-                    fmt.warn "Association {group:#{pname} <-> group:#{cname}}}"\
-                      " already exists, skipping.\n" 
-                    fmt.puts 4, '- already exists, skipping.'
-                    fmt.puts 4, '- OK'
-                    next
-                  end
-                  
-                  # Add new association
-                  cgroup = db.models[:group].find(name: cname)
-                  if cgroup.nil?
-                    warn_count += 1
-                    fmt.warn "Group '#{cname}' does not exist and will be created.\n"
-                    fmt.puts 4, '- child group does not exist, creating now...'
-                    cgroup = db.models[:group].create(name: cname)
-                    fmt.puts 6, '- OK'
-                  end
-                  pgroup.add_child(cgroup)
+                # Check against existing associations
+                unless groups_ds[name: cname].nil?
+                  warn_count += 1
+                  fmt.warn "Association {group:#{pname} <-> group:#{cname}}}"\
+                    " already exists, skipping.\n"
+                  fmt.puts 4, '- already exists, skipping.'
                   fmt.puts 4, '- OK'
+                  next
+                 end
+
+                # Add new association
+                cgroup = db.models[:group].find(name: cname)
+                if cgroup.nil?
+                  warn_count += 1
+                  fmt.warn "Group '#{cname}' does not exist and will be created.\n"
+                  fmt.puts 4, '- child group does not exist, creating now...'
+                  cgroup = db.models[:group].create(name: cname)
+                  fmt.puts 6, '- OK'
                 end
-                fmt.puts 2, '- all OK'
+                pgroup.add_child(cgroup)
+                fmt.puts 4, '- OK'
+              end
+              fmt.puts 2, '- all OK'
             end # Transaction end
           rescue db.exceptions[:moose] => e
-              abort("ERROR: #{e}")
+            abort("ERROR: #{e}")
           end
           if warn_count == 0
             puts 'Succeeded.'
           else
             puts 'Succeeded, with warnings.'
           end
-                    
         end
       end
     end
   end
 end
-
-

data/lib/moose_inventory/cli/group_addhost.rb

@@ -14,7 +14,7 @@ module Moose
           # Sanity
           if args.length < 2
             abort("ERROR: Wrong number of arguments, #{args.length} "\
-              "for 2 or more.")
+              'for 2 or more.')
           end
 
           # Arguments
@@ -32,27 +32,25 @@ module Moose
 
           # Transaction
           warn_count = 0
-          begin 
+          begin
             db.transaction do # Transaction start
               puts "Associate group '#{name}' with host(s) '#{hosts.join(',')}':"
               # Get the target group
               fmt.puts 2, "- retrieve group '#{name}'..."
               group = db.models[:group].find(name: name)
-              if group.nil?
-                abort("ERROR: The group '#{name}' does not exist.")
-              end
-              fmt.puts 4,  '- OK'
+              abort("ERROR: The group '#{name}' does not exist.") if group.nil?
+              fmt.puts 4, '- OK'
 
               # Associate group with the hosts
-              ungrouped  = db.models[:group].find_or_create(name: 'ungrouped')
+              ungrouped = db.models[:group].find_or_create(name: 'ungrouped')
               hosts_ds = group.hosts_dataset
-              hosts.each do |h| # rubocop:disable Style/Next
-                fmt.puts 2, "- add association {group:#{name} <-> host:#{ h }}..."
+              hosts.each do |h|
+                fmt.puts 2, "- add association {group:#{name} <-> host:#{h}}..."
 
                 # Check against existing associations
                 unless hosts_ds[name: h].nil?
                   warn_count += 1
-                  fmt.warn "Association {group:#{name} <-> host:#{ h }} already"\
+                  fmt.warn "Association {group:#{name} <-> host:#{h}} already"\
                     " exists, skipping.\n"
                   fmt.puts 4, '- already exists, skipping.'
                   fmt.puts 4, '- OK'
@@ -68,17 +66,16 @@ module Moose
                   host = db.models[:host].create(name: h)
                   fmt.puts 6, '- OK'
                 end
-                  
+
                 group.add_host(host)
                 fmt.puts 4, '- OK'
 
                 # Remove the host from the ungrouped group, if necessary
-                unless host.groups_dataset[name: 'ungrouped'].nil?
-                  fmt.puts 2,'- remove automatic association '\
-                    "{group:ungrouped <-> host:#{h}}..."
-                  host.remove_group(ungrouped)
-                  fmt.puts 4, '- OK'
-                end
+                next if host.groups_dataset[name: 'ungrouped'].nil?
+                fmt.puts 2, '- remove automatic association '\
+                  "{group:ungrouped <-> host:#{h}}..."
+                host.remove_group(ungrouped)
+                fmt.puts 4, '- OK'
               end
               fmt.puts 2, '- all OK'
             end # Transaction end
@@ -91,7 +88,6 @@ module Moose
             puts 'Succeeded, with warnings.'
           end
         end
-
       end
     end
   end

data/lib/moose_inventory/cli/group_addvar.rb

@@ -22,49 +22,49 @@ module Moose
           # Arguments
           name = args[0].downcase
           vars = args.slice(1, args.length - 1).uniq
-          
-        # Transaction
-        db.transaction do # Transaction start
-          puts "Add variables '#{vars.join(",")}' to group '#{name}':"
-          fmt.puts 2,"- retrieve group '#{name}'..."
-          group = db.models[:group].find(name: name)
-          if group.nil?
-            fail db.exceptions[:moose],
-                 "The group '#{name}' does not exist."
-          end
-          fmt.puts 4, '- OK'
-
-          groupvars_ds = group.groupvars_dataset
-          vars.each do |v|
-            fmt.puts 2, "- add variable '#{v}'..."
-            vararray = v.split('=')
 
-            if v.start_with?('=') ||  v.end_with?('=') || vararray.length != 2
+          # Transaction
+          db.transaction do # Transaction start
+            puts "Add variables '#{vars.join(',')}' to group '#{name}':"
+            fmt.puts 2, "- retrieve group '#{name}'..."
+            group = db.models[:group].find(name: name)
+            if group.nil?
               fail db.exceptions[:moose],
-                   "Incorrect format in '{#{v}}'. Expected 'key=value'."
+                   "The group '#{name}' does not exist."
             end
- 
-            # Check against existing associations
-            groupvar = groupvars_ds[name: vararray[0]]
-            if !groupvar.nil?
-              unless groupvar[:value] == vararray[1]
-                fmt.puts 4, '- already exists, applying as an update...'
-                update = db.models[:groupvar].find(id: groupvar[:id])
-                update[:value] = vararray[1]
-                update.save
+            fmt.puts 4, '- OK'
+
+            groupvars_ds = group.groupvars_dataset
+            vars.each do |v|
+              fmt.puts 2, "- add variable '#{v}'..."
+              vararray = v.split('=')
+
+              if v.start_with?('=') || v.end_with?('=') || vararray.length != 2
+                fail db.exceptions[:moose],
+                     "Incorrect format in '{#{v}}'. Expected 'key=value'."
               end
-            else
-              # groupvar doesn't exist, so create and associate
-              groupvar = db.models[:groupvar].create(name: vararray[0],
-                                                    value: vararray[1])
-              group.add_groupvar(groupvar)
+
+              # Check against existing associations
+              groupvar = groupvars_ds[name: vararray[0]]
+              if !groupvar.nil?
+                unless groupvar[:value] == vararray[1]
+                  fmt.puts 4, '- already exists, applying as an update...'
+                  update = db.models[:groupvar].find(id: groupvar[:id])
+                  update[:value] = vararray[1]
+                  update.save
+                end
+              else
+                # groupvar doesn't exist, so create and associate
+                groupvar = db.models[:groupvar].create(name: vararray[0],
+                                                       value: vararray[1])
+                group.add_groupvar(groupvar)
+              end
+              fmt.puts 4, '- OK'
             end
-            fmt.puts 4, '- OK'
-          end
-          fmt.puts 2, '- all OK'
-        end # Transaction end
+            fmt.puts 2, '- all OK'
+          end # Transaction end
 
-        puts 'Succeeded.'
+          puts 'Succeeded.'
         end
       end
     end

data/lib/moose_inventory/cli/group_get.rb

@@ -9,13 +9,13 @@ module Moose
       class Group
         desc 'get GROUP_1 [GROUP_2 ...]', 'Get groups GROUP_n from the inventory'
         def get(*argv) # rubocop:disable Metrics/AbcSize
-          if argv.length < 1
+          if argv.empty?
             abort('ERROR: Wrong number of arguments, '\
               "#{argv.length} for 1 or more")
           end
 
           # Convenience
-          db    = Moose::Inventory::DB
+          db = Moose::Inventory::DB
           fmt = Moose::Inventory::Cli::Formatter
 
           # Arguments
@@ -25,32 +25,29 @@ module Moose
           results = {}
           names.each do |name|
             group = db.models[:group].find(name: name)
-              
-            unless group.nil?
-              hosts = group.hosts_dataset.map(:name)
-            
-              children = group.children_dataset.map(:name)
-              
-              groupvars = {}
-              group.groupvars_dataset.each do |gv|
-                groupvars[gv[:name].to_sym] = gv[:value]
-              end
-
-              results[group[:name].to_sym] = {}
-              unless hosts.length == 0
-                results[group[:name].to_sym][:hosts]     = hosts
-              end
-
-              unless children.length == 0
-                results[group[:name].to_sym][:children] = children
-              end
-              
-              unless groupvars.length == 0
-                results[group[:name].to_sym][:groupvars] = groupvars
-              end
+
+            next if group.nil?
+            hosts = group.hosts_dataset.map(:name)
+
+            children = group.children_dataset.map(:name)
+
+            groupvars = {}
+            group.groupvars_dataset.each do |gv|
+              groupvars[gv[:name].to_sym] = gv[:value]
+            end
+
+            results[group[:name].to_sym] = {}
+            results[group[:name].to_sym][:hosts] = hosts unless hosts.empty?
+
+            unless children.empty?
+              results[group[:name].to_sym][:children] = children
+            end
+
+            unless groupvars.empty?
+              results[group[:name].to_sym][:groupvars] = groupvars
             end
           end
-          
+
           fmt.dump(results)
         end
       end

data/lib/moose_inventory/cli/group_list.rb

@@ -12,41 +12,38 @@ module Moose
              'List the groups, together with any associated hosts and groupvars'
         def list # rubocop:disable Metrics/AbcSize
           # Convenience
-          db    = Moose::Inventory::DB
+          db = Moose::Inventory::DB
           confopts = Moose::Inventory::Config._confopts
-          
+
           # Process
           results = {}
           db.models[:group].all.each do |group|
-            
             hosts = group.hosts_dataset.map(:name)
 
             # Hide the automatic ungrouped group, if it's empty
-            next if group[:name] == 'ungrouped' && hosts.length == 0
+            next if group[:name] == 'ungrouped' && hosts.empty?
 
             children = group.children_dataset.map(:name)
-                          
+
             groupvars = {}
             group.groupvars_dataset.each do |gv|
               groupvars[gv[:name].to_sym] = gv[:value]
             end
 
-              
             results[group[:name].to_sym] = {}
-            unless hosts.length == 0  and confopts[:ansible] != true 
+            unless hosts.empty? && (confopts[:ansible] != true)
               results[group[:name].to_sym][:hosts] = hosts
             end
 
-            unless children.length == 0
+            unless children.empty?
               results[group[:name].to_sym][:children] = children
             end
-            
-            unless groupvars.length == 0
-              if confopts[:ansible] == true
-                results[group[:name].to_sym][:vars] = groupvars
-              else
-                results[group[:name].to_sym][:groupvars] = groupvars
-              end
+
+            next if groupvars.empty?
+            if confopts[:ansible] == true
+              results[group[:name].to_sym][:vars] = groupvars
+            else
+              results[group[:name].to_sym][:groupvars] = groupvars
             end
           end
           Formatter.out(results)

data/lib/moose_inventory/cli/group_listvars.rb

@@ -19,23 +19,22 @@ module Moose
           # Note, the Ansible spects don't call for a "--group GROUPNAME" method.
           # So, strictly, there is no Ansible compatibility for this method.
           # Instead, the Ansible compatibility included herein is for consistency
-          # with the "hosts listvars" method, which services the Ansible 
+          # with the "hosts listvars" method, which services the Ansible
           # "--host HOSTNAME" specs.
-                     
+
           # sanity
           if confopts[:ansible] == true
             if argv.length != 1
-            abort('ERROR: Wrong number of arguments for Ansible mode, '\
-                  "#{args.length} for 1.")
+              abort('ERROR: Wrong number of arguments for Ansible mode, '\
+                    "#{args.length} for 1.")
             end
           else
-            if argv.length < 1
+            if argv.empty?
               abort('ERROR: Wrong number of arguments, '\
                     "#{args.length} for 1 or more.")
             end
           end
 
-
           # Convenience
           db = Moose::Inventory::DB
           fmt = Moose::Inventory::Cli::Formatter
@@ -43,10 +42,10 @@ module Moose
           # Arguments
           names = argv.uniq.map(&:downcase)
 
-          #process
+          # process
           results = {}
-            
-          if confopts[:ansible] == true 
+
+          if confopts[:ansible] == true
             # This is the implementation per Ansible specs
             name = names.first
             group = db.models[:group].find(name: name)
@@ -61,11 +60,10 @@ module Moose
             # This our more flexible implementation
             names.each do |name|
               group = db.models[:group].find(name: name)
-              unless group.nil?
-                results[name.to_sym] = {}
-                group.groupvars_dataset.each do |gv|
-                  results[name.to_sym][gv[:name].to_sym] = gv[:value]
-                end
+              next if group.nil?
+              results[name.to_sym] = {}
+              group.groupvars_dataset.each do |gv|
+                results[name.to_sym][gv[:name].to_sym] = gv[:value]
               end
             end
           end