oxidized 0.25.1 → 0.26.0

data/lib/oxidized/output/gitcrypt.rb

@@ -36,7 +36,7 @@ module Oxidized
       end
     end
 
-    def crypt_init repo
+    def crypt_init(repo)
       repo.chdir do
         system(@gitcrypt_init)
         @cfg.users.each do |user|
@@ -48,22 +48,22 @@ module Oxidized
       end
     end
 
-    def lock repo
+    def lock(repo)
       repo.chdir do
         system(@gitcrypt_lock)
       end
     end
 
-    def unlock repo
+    def unlock(repo)
       repo.chdir do
         system(@gitcrypt_unlock)
       end
     end
 
-    def store file, outputs, opt = {}
+    def store(file, outputs, opt = {})
       @msg   = opt[:msg]
-      @user  = (opt[:user]  or @cfg.user)
-      @email = (opt[:email] or @cfg.email)
+      @user  = (opt[:user]  || @cfg.user)
+      @email = (opt[:email] || @cfg.email)
       @opt   = opt
       @commitref = nil
       repo = @cfg.repo
@@ -72,7 +72,7 @@ module Oxidized
         type_cfg = ''
         type_repo = File.join(File.dirname(repo), type + '.git')
         outputs.type(type).each do |output|
-          (type_cfg << output; next) if not output.name
+          (type_cfg << output; next) unless output.name # rubocop:disable Style/Semicolon
           type_file = file + '--' + output.name
           if @cfg.type_as_directory?
             type_file = type + '/' + type_file
@@ -86,97 +86,85 @@ module Oxidized
       update repo, file, outputs.to_cfg
     end
 
-    def fetch node, group
-      begin
-        repo, path = yield_repo_and_path(node, group)
-        repo = Git.open repo
-        unlock repo
-        index = repo.index
-        # Empty repo ?
-        empty = File.exists? index.path
-        if empty
-          raise 'Empty git repo'
-        else
-          File.read path
-        end
-
-        lock repo
-      rescue
-        'node not found'
-      end
+    def fetch(node, group)
+      repo, path = yield_repo_and_path(node, group)
+      repo = Git.open repo
+      unlock repo
+      index = repo.index
+      # Empty repo ?
+      raise 'Empty git repo' if File.exist?(index.path)
+
+      File.read path
+      lock repo
+    rescue StandardError
+      'node not found'
     end
 
     # give a hash of all oid revision for the given node, and the date of the commit
-    def version node, group
-      begin
-        repo, path = yield_repo_and_path(node, group)
-
-        repo = Git.open repo
-        unlock repo
-        walker = repo.log.path(path)
-        i = -1
-        tab = []
-        walker.each do |commit|
-          hash = {}
-          hash[:date] = commit.date.to_s
-          hash[:oid] = commit.objectish
-          hash[:author] = commit.author
-          hash[:message] = commit.message
-          tab[i += 1] = hash
-        end
-        walker.reset
-        tab
-      rescue
-        'node not found'
+    def version(node, group)
+      repo, path = yield_repo_and_path(node, group)
+
+      repo = Git.open repo
+      unlock repo
+      walker = repo.log.path(path)
+      i = -1
+      tab = []
+      walker.each do |commit|
+        hash = {}
+        hash[:date] = commit.date.to_s
+        hash[:oid] = commit.objectish
+        hash[:author] = commit.author
+        hash[:message] = commit.message
+        tab[i += 1] = hash
       end
+      walker.reset
+      tab
+    rescue StandardError
+      'node not found'
     end
 
     # give the blob of a specific revision
-    def get_version node, group, oid
-      begin
-        repo, path = yield_repo_and_path(node, group)
-        repo = Git.open repo
-        unlock repo
-        repo.gtree(oid).files[path].contents
-      rescue
-        'version not found'
-      ensure
-        lock repo
-      end
+    def get_version(node, group, oid)
+      repo, path = yield_repo_and_path(node, group)
+      repo = Git.open repo
+      unlock repo
+      repo.gtree(oid).files[path].contents
+    rescue StandardError
+      'version not found'
+    ensure
+      lock repo
     end
 
     # give a hash with the patch of a diff between 2 revision and the stats (added and deleted lines)
-    def get_diff node, group, oid1, oid2
-      begin
-        diff_commits = nil
-        repo, path = yield_repo_and_path(node, group)
-        repo = Git.open repo
-        unlock repo
-        commit = repo.gcommit(oid1)
-
-        if oid2
-          commit_old = repo.gcommit(oid2)
-          diff = repo.diff(commit_old, commit)
-          stats = [diff.stats[:files][node.name][:insertions], diff.stats[:files][node.name][:deletions]]
-          diff.each do |patch|
-            if /#{node.name}\s+/.match(patch.patch.to_s.lines.first)
-              diff_commits = { :patch => patch.patch.to_s, :stat => stats }
-              break
-            end
+    def get_diff(node, group, oid1, oid2)
+      diff_commits = nil
+      repo, _path = yield_repo_and_path(node, group)
+      repo = Git.open repo
+      unlock repo
+      commit = repo.gcommit(oid1)
+
+      if oid2
+        commit_old = repo.gcommit(oid2)
+        diff = repo.diff(commit_old, commit)
+        stats = [diff.stats[:files][node.name][:insertions], diff.stats[:files][node.name][:deletions]]
+        diff.each do |patch|
+          if /#{node.name}\s+/ =~ patch.patch.to_s.lines.first
+            diff_commits = { patch: patch.patch.to_s, stat: stats }
+            break
           end
-        else
-          stat = commit.parents[0].diff(commit).stats
-          stat = [stat[:files][node.name][:insertions], stat[:files][node.name][:deletions]]
-          patch = commit.parents[0].diff(commit).patch
-          diff_commits = { :patch => patch, :stat => stat }
         end
-        lock repo
-        diff_commits
-      rescue
-        'no diffs'
-      ensure
-        lock repo
+      else
+        stat = commit.parents[0].diff(commit).stats
+        stat = [stat[:files][node.name][:insertions], stat[:files][node.name][:deletions]]
+        patch = commit.parents[0].diff(commit).patch
+        diff_commits = { patch: patch, stat: stat }
       end
+      lock repo
+      diff_commits
+    rescue StandardError
+      'no diffs'
+    ensure
+      lock repo
     end
 
     private
@@ -184,14 +172,12 @@ module Oxidized
     def yield_repo_and_path(node, group)
       repo, path = node.repo, node.name
 
-      if group and @cfg.single_repo?
-        path = "#{group}/#{node.name}"
-      end
+      path = "#{group}/#{node.name}" if group && @cfg.single_repo?
 
       [repo, path]
     end
 
-    def update repo, file, data
+    def update(repo, file, data)
       return if data.empty?
 
       if @opt[:group]
@@ -213,14 +199,14 @@ module Oxidized
         begin
           grepo = Git.init repo
           crypt_init grepo
-        rescue => create_error
+        rescue StandardError => create_error
           raise GitCryptError, "first '#{open_error.message}' was raised while opening git repo, then '#{create_error.message}' was while trying to create git repo"
         end
         retry
       end
     end
 
-    def update_repo repo, file, data, msg, user, email
+    def update_repo(repo, file, data, msg, user, email)
       grepo = Git.open repo
       grepo.config('user.name', user)
       grepo.config('user.email', email)

data/lib/oxidized/output/http.rb

@@ -6,25 +6,25 @@ module Oxidized
     end
 
     def setup
-      if @cfg.empty?
-        CFGS.user.output.http.user = 'Oxidized'
-        CFGS.user.output.http.pasword = 'secret'
-        CFGS.user.output.http.url = 'http://localhost/web-api/oxidized'
-        CFGS.save :user
-        raise NoConfig, 'no output http config, edit ~/.config/oxidized/config'
-      end
+      return unless @cfg.empty?
+
+      CFGS.user.output.http.user = 'Oxidized'
+      CFGS.user.output.http.pasword = 'secret'
+      CFGS.user.output.http.url = 'http://localhost/web-api/oxidized'
+      CFGS.save :user
+      raise NoConfig, 'no output http config, edit ~/.config/oxidized/config'
     end
 
     require "net/http"
     require "uri"
     require "json"
 
-    def store node, outputs, opt = {}
+    def store(node, outputs, opt = {})
       @commitref = nil
       uri = URI.parse @cfg.url
       http = Net::HTTP.new uri.host, uri.port
       # http.use_ssl = true if uri.scheme = 'https'
-      req = Net::HTTP::Post.new(uri.request_uri, initheader = { 'Content-Type' => 'application/json' })
+      req = Net::HTTP::Post.new(uri.request_uri, 'Content-Type' => 'application/json')
       req.basic_auth @cfg.user, @cfg.password
       req.body = generate_json(node, outputs, opt)
       response = http.request req
@@ -44,17 +44,15 @@ module Oxidized
 
     private
 
-    def generate_json node, outputs, opt
+    def generate_json(node, outputs, opt)
       JSON.pretty_generate(
-        {
-          'msg'    => opt[:msg],
-          'user'   => opt[:user],
-          'email'  => opt[:email],
-          'group'  => opt[:group],
-          'node'   => node,
-          'config' => outputs.to_cfg,
-          # actually we need to also iterate outputs, for other types like in gitlab. But most people don't use 'type' functionality.
-        }
+        'msg'    => opt[:msg],
+        'user'   => opt[:user],
+        'email'  => opt[:email],
+        'group'  => opt[:group],
+        'node'   => node,
+        'config' => outputs.to_cfg
+        # actually we need to also iterate outputs, for other types like in gitlab. But most people don't use 'type' functionality.
       )
     end
   end

data/lib/oxidized/output/output.rb

@@ -2,7 +2,7 @@ module Oxidized
   class Output
     class NoConfig < OxidizedError; end
 
-    def cfg_to_str cfg
+    def cfg_to_str(cfg)
       cfg.select { |h| h[:type] == 'cfg' }.map { |h| h[:data] }.join
     end
   end

data/lib/oxidized/source/csv.rb

@@ -18,10 +18,10 @@ module Oxidized
       require 'gpgme' if @cfg.gpg?
     end
 
-    def load _node_want = nil
+    def load(_node_want = nil)
       nodes = []
       open_file.each_line do |line|
-        next if line.match(/^\s*#/)
+        next if line =~ /^\s*#/
 
         data = line.chomp.split(@cfg.delimiter, -1)
         next if data.empty?
@@ -53,7 +53,7 @@ module Oxidized
         crypto = GPGME::Crypto.new password: @cfg.gpg_password
         crypto.decrypt(File.open(file)).to_s
       else
-        open(file)
+        File.open(file)
       end
     end
   end

data/lib/oxidized/source/http.rb

@@ -6,9 +6,9 @@ module Oxidized
     end
 
     def setup
-      if @cfg.url.empty?
-        raise NoConfig, 'no source http url config, edit ~/.config/oxidized/config'
-      end
+      return unless @cfg.url.empty?
+
+      raise NoConfig, 'no source http url config, edit ~/.config/oxidized/config'
     end
 
     require "net/http"
@@ -16,7 +16,7 @@ module Oxidized
     require "uri"
     require "json"
 
-    def load node_want = nil
+    def load(node_want = nil)
       nodes = []
       data = JSON.parse(read_http(node_want))
       data = string_navigate(data, @cfg.hosts_location) if @cfg.hosts_location?
@@ -44,17 +44,18 @@ module Oxidized
 
     private
 
-    def string_navigate object, wants
-      wants.split(".").map do |want|
+    def string_navigate(object, wants)
+      wants = wants.split(".").map do |want|
         head, match, _tail = want.partition(/\[\d+\]/)
         match.empty? ? head : [head, match[1..-2].to_i]
-      end.flatten.each do |want|
+      end
+      wants.flatten.each do |want|
         object = object[want] if object.respond_to? :each
       end
       object
     end
 
-    def read_http node_want
+    def read_http(node_want)
       uri = URI.parse(@cfg.url)
       http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = true if uri.scheme == 'https'
@@ -67,13 +68,9 @@ module Oxidized
       end
 
       req_uri = uri.request_uri
-      if node_want
-        req_uri = "#{req_uri}/#{node_want}"
-      end
+      req_uri = "#{req_uri}/#{node_want}" if node_want
       request = Net::HTTP::Get.new(req_uri, headers)
-      if (@cfg.user? && @cfg.pass?)
-        request.basic_auth(@cfg.user, @cfg.pass)
-      end
+      request.basic_auth(@cfg.user, @cfg.pass) if @cfg.user? && @cfg.pass?
       http.request(request).body
     end
   end

data/lib/oxidized/source/source.rb

@@ -3,14 +3,14 @@ module Oxidized
     class NoConfig < OxidizedError; end
 
     def initialize
-      @map = (Oxidized.config.model_map or {})
+      @map = (Oxidized.config.model_map || {})
     end
 
-    def map_model model
+    def map_model(model)
       @map.has_key?(model) ? @map[model] : model
     end
 
-    def node_var_interpolate var
+    def node_var_interpolate(var)
       case var
       when "nil"   then nil
       when "false" then false

data/lib/oxidized/source/sql.rb

@@ -7,26 +7,24 @@ module Oxidized
     end
 
     def setup
-      if @cfg.empty?
-        Oxidized.asetus.user.source.sql.adapter   = 'sqlite'
-        Oxidized.asetus.user.source.sql.database  = File.join(Config::Root, 'sqlite.db')
-        Oxidized.asetus.user.source.sql.table     = 'devices'
-        Oxidized.asetus.user.source.sql.map.name  = 'name'
-        Oxidized.asetus.user.source.sql.map.model = 'rancid'
-        Oxidized.asetus.save :user
-        raise NoConfig, 'no source sql config, edit ~/.config/oxidized/config'
-      end
+      return unless @cfg.empty?
+
+      Oxidized.asetus.user.source.sql.adapter   = 'sqlite'
+      Oxidized.asetus.user.source.sql.database  = File.join(Config::Root, 'sqlite.db')
+      Oxidized.asetus.user.source.sql.table     = 'devices'
+      Oxidized.asetus.user.source.sql.map.name  = 'name'
+      Oxidized.asetus.user.source.sql.map.model = 'rancid'
+      Oxidized.asetus.save :user
+      raise NoConfig, 'no source sql config, edit ~/.config/oxidized/config'
     end
 
-    def load node_want = nil
+    def load(node_want = nil)
       nodes = []
       db = connect
       query = db[@cfg.table.to_sym]
       query = query.with_sql(@cfg.query) if @cfg.query?
 
-      if node_want
-        query = query.where(@cfg.map.name.to_sym => node_want)
-      end
+      query = query.where(@cfg.map.name.to_sym => node_want) if node_want
 
       query.each do |node|
         # map node parameters
@@ -55,11 +53,11 @@ module Oxidized
     end
 
     def connect
-      Sequel.connect(:adapter  => @cfg.adapter,
-                     :host     => @cfg.host?,
-                     :user     => @cfg.user?,
-                     :password => @cfg.password?,
-                     :database => @cfg.database)
+      Sequel.connect(adapter:  @cfg.adapter,
+                     host:     @cfg.host?,
+                     user:     @cfg.user?,
+                     password: @cfg.password?,
+                     database: @cfg.database)
     rescue Sequel::AdapterNotFound => error
       raise OxidizedError, "SQL adapter gem not installed: " + error.message
     end