hiera-eyaml 3.4.0 → 4.0.0

data/lib/hiera/backend/eyaml/subcommands/edit.rb

@@ -9,24 +9,21 @@ class Hiera
   module Backend
     module Eyaml
       module Subcommands
-
         class Edit < Subcommand
-
           def self.options
-            [{ :name => :no_preamble,
-               :description => "Don't prefix edit sessions with the informative preamble" },
-             {:name => :no_decrypt,
-              :short => "-d",
-              :description => "Do not decrypt existing encrypted content. New content marked properly will be encrypted."}
-            ]
+            [{ name: :no_preamble,
+               description: "Don't prefix edit sessions with the informative preamble", },
+             { name: :no_decrypt,
+               short: '-d',
+               description: 'Do not decrypt existing encrypted content. New content marked properly will be encrypted.', },]
           end
 
           def self.description
-            "edit an eyaml file"
+            'edit an eyaml file'
           end
 
           def self.helptext
-            "Usage: eyaml edit [options] <some-eyaml-file>"
+            'Usage: eyaml edit [options] <some-eyaml-file>'
           end
 
           def self.prefix
@@ -34,40 +31,40 @@ class Hiera
           end
 
           def self.preamble
-            tags = (["pkcs7"] + Plugins.plugins.collect {|plugin|
-              plugin.name.split("hiera-eyaml-").last
-            }).collect{|name| Encryptor.find(name).tag}
-
-            preamble = <<-eos
-This is eyaml edit mode. This text (lines starting with #{self.prefix} at the top of
-the file) will be removed when you save and exit.
- - To edit encrypted values, change the content of the DEC(<num>)::PKCS7[]!
-   block#{(tags.size>1) ? " (or #{tags.drop(1).collect {|tag| "DEC(<num>)::#{tag}[]!" }.join(' or ')})." : '.' }
-   WARNING: DO NOT change the number in the parentheses.
- - To add a new encrypted value copy and paste a new block from the
-   appropriate example below. Note that:
-    * the text to encrypt goes in the square brackets
-    * ensure you include the exclamation mark when you copy and paste
-    * you must not include a number when adding a new block
-   e.g. #{tags.collect {|tag| "DEC::#{tag}[]!" }.join(' -or- ')}
-eos
-
-            preamble.gsub(/^/, "#{self.prefix} ")
+            tags = (['pkcs7'] + Plugins.plugins.collect do |plugin|
+              plugin.name.split('hiera-eyaml-').last
+            end).collect { |name| Encryptor.find(name).tag }
+
+            preamble = <<~EOS
+              This is eyaml edit mode. This text (lines starting with #{prefix} at the top of
+              the file) will be removed when you save and exit.
+               - To edit encrypted values, change the content of the DEC(<num>)::PKCS7[]!
+                 block#{(tags.size > 1) ? " (or #{tags.drop(1).collect { |tag| "DEC(<num>)::#{tag}[]!" }.join(' or ')})." : '.'}
+                 WARNING: DO NOT change the number in the parentheses.
+               - To add a new encrypted value copy and paste a new block from the
+                 appropriate example below. Note that:
+                  * the text to encrypt goes in the square brackets
+                  * ensure you include the exclamation mark when you copy and paste
+                  * you must not include a number when adding a new block
+                 e.g. #{tags.collect { |tag| "DEC::#{tag}[]!" }.join(' -or- ')}
+            EOS
+
+            preamble.gsub(/^/, "#{prefix} ")
           end
 
-          def self.validate options
-            Optimist::die "You must specify an eyaml file" if ARGV.empty?
+          def self.validate(options)
+            Optimist.die 'You must specify an eyaml file' if ARGV.empty?
             options[:source] = :eyaml
             options[:eyaml] = ARGV.shift
             if File.exist? options[:eyaml]
               begin
                 options[:input_data] = File.read options[:eyaml]
-              rescue
+              rescue StandardError
                 raise StandardError, "Could not open file for reading: #{options[:eyaml]}"
               end
             else
               LoggingHelper.info "#{options[:eyaml]} doesn't exist, editing new file"
-              options[:input_data] = "---"
+              options[:input_data] = '---'
             end
             options
           end
@@ -80,42 +77,48 @@ eos
             # The 'no_' option has special handling - bypass that and just check if a flag was set.
             if Eyaml::Options[:no_decrypt_given]
               decrypted_input = Eyaml::Options[:input_data]
-              decrypted_file_content = Eyaml::Options[:no_preamble] ? decrypted_input : (self.preamble + decrypted_input)
+              decrypted_file_content = Eyaml::Options[:no_preamble] ? decrypted_input : (preamble + decrypted_input)
             else
               encrypted_parser = Parser::ParserFactory.encrypted_parser
               tokens = encrypted_parser.parse Eyaml::Options[:input_data]
-              decrypted_input = tokens.each_with_index.to_a.map{|(t,index)| t.to_decrypted :index => index}.join
-              decrypted_file_content = Eyaml::Options[:no_preamble] ? decrypted_input : (self.preamble + decrypted_input)
+              decrypted_input = tokens.each_with_index.to_a.map { |(t, index)| t.to_decrypted index: index }.join
+              decrypted_file_content = Eyaml::Options[:no_preamble] ? decrypted_input : (preamble + decrypted_input)
             end
 
             begin
-              decrypted_file = EditHelper.write_tempfile decrypted_file_content unless decrypted_file
+              decrypted_file ||= EditHelper.write_tempfile decrypted_file_content
               system "#{editor} \"#{decrypted_file}\""
               status = $?
 
-              raise StandardError, "File was moved by editor" unless File.file? decrypted_file
+              raise StandardError, 'File was moved by editor' unless File.file? decrypted_file
+
               raw_edited_file = File.read decrypted_file
               # strip comments at start of file
-              edited_file = raw_edited_file.split($/,-1).drop_while {|line| line.start_with?(self.prefix)}.join($/)
+              edited_file = raw_edited_file.split($/, -1).drop_while { |line| line.start_with?(prefix) }.join($/)
 
               raise StandardError, "Editor #{editor} has not exited?" unless status.exited?
-              raise StandardError, "Editor did not exit successfully (exit code #{status.exitstatus}), aborting" unless status.exitstatus == 0
-              raise StandardError, "Edited file is blank" if edited_file.empty?
+
+              unless status.exitstatus == 0
+                raise StandardError,
+                      "Editor did not exit successfully (exit code #{status.exitstatus}), aborting"
+              end
+              raise StandardError, 'Edited file is blank' if edited_file.empty?
 
               if edited_file == decrypted_input
-                LoggingHelper.info "No changes detected, exiting"
+                LoggingHelper.info 'No changes detected, exiting'
               else
                 decrypted_parser = Parser::ParserFactory.decrypted_parser
                 edited_tokens = decrypted_parser.parse(edited_file)
 
                 # check that the tokens haven't been copy / pasted
-                used_ids = edited_tokens.find_all{ |t| t.class.name =~ /::EncToken$/ and !t.id.nil? }.map{ |t| t.id }
+                used_ids = edited_tokens.find_all { |t| t.class.name =~ /::EncToken$/ and !t.id.nil? }.map { |t| t.id }
                 if used_ids.length != used_ids.uniq.length
-                    raise RecoverableError, "A duplicate DEC(ID) was found so I don't know how to proceed. This is probably because you copy and pasted a value - if you do this please delete the ID and parentheses"
+                  raise RecoverableError,
+                        "A duplicate DEC(ID) was found so I don't know how to proceed. This is probably because you copy and pasted a value - if you do this please delete the ID and parentheses"
                 end
 
                 # replace untouched values with the source values
-                edited_denoised_tokens = edited_tokens.map{ |token|
+                edited_denoised_tokens = edited_tokens.map do |token|
                   if token.class.name =~ /::EncToken$/ && !token.id.nil?
                     old_token = tokens[token.id]
                     if old_token.plain_text.eql? token.plain_text
@@ -126,31 +129,27 @@ eos
                   else
                     token
                   end
-                }
+                end
 
-                encrypted_output = edited_denoised_tokens.map{ |t| t.to_encrypted }.join
+                encrypted_output = edited_denoised_tokens.map { |t| t.to_encrypted }.join
 
                 filename = Eyaml::Options[:eyaml]
-                File.open("#{filename}", 'w') { |file|
-                  file.write encrypted_output
-                }
+                File.write("#{filename}", encrypted_output)
               end
             rescue RecoverableError => e
               LoggingHelper.info e
-              if agree "Return to the editor to try again?"
-                retry
-              else
-                raise e
-              end
+              raise e unless agree 'Return to the editor to try again?'
+
+              retry
             ensure
-              EditHelper.secure_file_delete :file => decrypted_file, :num_bytes => [edited_file.length, decrypted_input.length].max
+              EditHelper.secure_file_delete file: decrypted_file,
+                                            num_bytes: [edited_file.length,
+                                                        decrypted_input.length,].max
             end
 
             nil
           end
-
         end
-
       end
     end
   end

data/lib/hiera/backend/eyaml/subcommands/encrypt.rb

@@ -7,94 +7,90 @@ class Hiera
   module Backend
     module Eyaml
       module Subcommands
-
         class Encrypt < Subcommand
-
           def self.options
-            [{:name => :password,
-              :description => "Source input is a password entered on the terminal",
-              :short => 'p'},
-             {:name => :string,
-              :description => "Source input is a string provided as an argument",
-              :short => 's',
-              :type => :string},
-             {:name => :file,
-              :description => "Source input is a regular file",
-              :short => 'f',
-              :type => :string},
-             {:name => :stdin,
-              :description => "Source input is taken from stdin",
-              :short => :none},
-             {:name => :eyaml,
-              :description => "Source input is an eyaml file",
-              :short => 'e',
-              :type => :string},
-             {:name => :output,
-              :description => "Output format of final result (examples, block, string)",
-              :type => :string,
-              :short => 'o',
-              :default => "examples"},
-             {:name => :label,
-              :description => "Apply a label to the encrypted result",
-              :short => 'l',
-              :type => :string}
-            ]
+            [{ name: :password,
+               description: 'Source input is a password entered on the terminal',
+               short: 'p', },
+             { name: :string,
+               description: 'Source input is a string provided as an argument',
+               short: 's',
+               type: :string, },
+             { name: :file,
+               description: 'Source input is a regular file',
+               short: 'f',
+               type: :string, },
+             { name: :stdin,
+               description: 'Source input is taken from stdin',
+               short: :none, },
+             { name: :eyaml,
+               description: 'Source input is an eyaml file',
+               short: 'e',
+               type: :string, },
+             { name: :output,
+               description: 'Output format of final result (examples, block, string)',
+               type: :string,
+               short: 'o',
+               default: 'examples', },
+             { name: :label,
+               description: 'Apply a label to the encrypted result',
+               short: 'l',
+               type: :string, },]
           end
 
           def self.description
-            "encrypt some data"
+            'encrypt some data'
           end
 
-          def self.validate options
-            sources = [:password, :string, :file, :stdin, :eyaml].collect {|x| x if options[x]}.compact
-            Optimist::die "You must specify a source" if sources.count.zero?
-            Optimist::die "You can only specify one of (#{sources.join(', ')})" if sources.count > 1
+          def self.validate(options)
+            sources = %i[password string file stdin eyaml].collect { |x| x if options[x] }.compact
+            Optimist.die 'You must specify a source' if sources.count.zero?
+            Optimist.die "You can only specify one of (#{sources.join(', ')})" if sources.count > 1
             options[:source] = sources.first
 
             options[:input_data] = case options[:source]
-            when :password
-              require 'hiera/backend/eyaml/highlinehelper'
-              HighlineHelper.read_password
-            when :string
-              options[:string]
-            when :file
-              File.read options[:file]
-            when :stdin
-              STDIN.read
-            when :eyaml
-              File.read options[:eyaml]
-            end
+                                   when :password
+                                     require 'hiera/backend/eyaml/highlinehelper'
+                                     HighlineHelper.read_password
+                                   when :string
+                                     options[:string]
+                                   when :file
+                                     File.read options[:file]
+                                   when :stdin
+                                     STDIN.read
+                                   when :eyaml
+                                     File.read options[:eyaml]
+                                   end
             options
-
           end
 
           def self.execute
             case Eyaml::Options[:source]
-              when :eyaml
-                parser = Parser::ParserFactory.decrypted_parser
-                tokens = parser.parse(Eyaml::Options[:input_data])
-                encrypted = tokens.map{ |token| token.to_encrypted }
-                encrypted.join
+            when :eyaml
+              parser = Parser::ParserFactory.decrypted_parser
+              tokens = parser.parse(Eyaml::Options[:input_data])
+              encrypted = tokens.map { |token| token.to_encrypted }
+              encrypted.join
+            else
+              encryptor = Encryptor.find
+              ciphertext = encryptor.encode(encryptor.encrypt(Eyaml::Options[:input_data]))
+              token = Parser::EncToken.new(:block, Eyaml::Options[:input_data], encryptor, ciphertext, nil, '  ')
+              case Eyaml::Options[:output]
+              when 'block'
+                token.to_encrypted label: Eyaml::Options[:label], use_chevron: !Eyaml::Options[:label].nil?,
+                                   format: :block
+              when 'string'
+                token.to_encrypted label: Eyaml::Options[:label], format: :string
+              when 'examples'
+                string = token.to_encrypted label: Eyaml::Options[:label] || 'string', format: :string
+                block = token.to_encrypted label: Eyaml::Options[:label] || 'block', format: :block
+                "#{string}\n\nOR\n\n#{block}"
               else
-                encryptor = Encryptor.find
-                ciphertext = encryptor.encode( encryptor.encrypt(Eyaml::Options[:input_data]) )
-                token = Parser::EncToken.new(:block, Eyaml::Options[:input_data], encryptor, ciphertext, nil, '  ')
-                case Eyaml::Options[:output]
-                  when "block"
-                    token.to_encrypted :label => Eyaml::Options[:label], :use_chevron => !Eyaml::Options[:label].nil?, :format => :block
-                  when "string"
-                    token.to_encrypted :label => Eyaml::Options[:label], :format => :string
-                  when "examples"
-                    string = token.to_encrypted :label => Eyaml::Options[:label] || 'string', :format => :string
-                    block = token.to_encrypted :label => Eyaml::Options[:label] || 'block', :format => :block
-                    "#{string}\n\nOR\n\n#{block}"
-                  else
-                    token.to_encrypted :format => :string
-                end
+                token.to_encrypted format: :string
+              end
             end
           end
         end
-
       end
     end
   end

data/lib/hiera/backend/eyaml/subcommands/help.rb

@@ -5,47 +5,42 @@ class Hiera
   module Backend
     module Eyaml
       module Subcommands
-
         class Help < Subcommand
-
           def self.options
             []
           end
 
           def self.description
-            "this page"
+            'this page'
           end
 
           def self.execute
+            puts <<~EOS
+              Welcome to eyaml #{Eyaml::VERSION}#{' '}
 
-            puts <<-EOS
-Welcome to eyaml #{Eyaml::VERSION} 
-
-Usage:
-eyaml subcommand [global-opts] [subcommand-opts]
+              Usage:
+              eyaml subcommand [global-opts] [subcommand-opts]
 
-Available subcommands:
-#{Eyaml.subcommands.collect {|command|
-  command_class = Subcommands.const_get(Utils.camelcase command)
-  sprintf "%15s: %-65s", command.downcase, command_class.description unless command_class.hidden?
-}.compact.join("\n")}
+              Available subcommands:
+              #{Eyaml.subcommands.collect do |command|
+                command_class = Subcommands.const_get(Utils.camelcase(command))
+                format '%15s: %-65s', command.downcase, command_class.description unless command_class.hidden?
+              end.compact.join("\n")}
 
-For more help on an individual command, use --help on that command
+              For more help on an individual command, use --help on that command
 
-Installed Plugins:
-#{Plugins.plugins.collect {|plugin| 
-  "\t" + plugin.name.split("hiera-eyaml-").last
-}.join("\n")}
-EOS
+              Installed Plugins:
+              #{Plugins.plugins.collect do |plugin| # {' '}
+                "\t" + plugin.name.split('hiera-eyaml-').last
+              end.join("\n")}
+            EOS
           end
 
           def self.hidden?
             true
           end
-
         end
-
       end
     end
   end
-end
+end

data/lib/hiera/backend/eyaml/subcommands/recrypt.rb

@@ -6,28 +6,26 @@ class Hiera
   module Backend
     module Eyaml
       module Subcommands
-
         class Recrypt < Subcommand
-
           def self.options
             [
-                 {:name          => :change_encryption,
-                  :description   => "Specify the new encryption method that should be used for the file",
-                  :short         => 'd',
-                  :default       => "pkcs7"}
-             ]
+              { name: :change_encryption,
+                description: 'Specify the new encryption method that should be used for the file',
+                short: 'd',
+                default: 'pkcs7', },
+            ]
           end
 
           def self.description
-            "recrypt an eyaml file"
+            'recrypt an eyaml file'
           end
 
           def self.helptext
-            "Usage: eyaml recrypt [options] <some-eyaml-file>"
+            'Usage: eyaml recrypt [options] <some-eyaml-file>'
           end
 
-          def self.validate options
-            Optimist::die "You must specify an eyaml file" if ARGV.empty?
+          def self.validate(options)
+            Optimist.die 'You must specify an eyaml file' if ARGV.empty?
             options[:source] = :eyaml
             options[:eyaml] = ARGV.shift
             options[:input_data] = File.read options[:eyaml]
@@ -35,27 +33,22 @@ class Hiera
             options
           end
 
-          def self.execute 
-
+          def self.execute
             encrypted_parser = Parser::ParserFactory.encrypted_parser
             tokens = encrypted_parser.parse Eyaml::Options[:input_data]
-            decrypted_input = tokens.each_with_index.to_a.map{|(t,index)| t.to_decrypted :index => index}.join
+            decrypted_input = tokens.each_with_index.to_a.map { |(t, index)| t.to_decrypted index: index }.join
 
             decrypted_parser = Parser::ParserFactory.decrypted_parser
             edited_tokens = decrypted_parser.parse(decrypted_input)
 
-            encrypted_output = edited_tokens.map{ |t| t.to_encrypted({:change_encryption => @change_encryption}) }.join
+            encrypted_output = edited_tokens.map { |t| t.to_encrypted({ change_encryption: @change_encryption }) }.join
 
             filename = Eyaml::Options[:eyaml]
-            File.open("#{filename}", 'w') { |file|
-              file.write encrypted_output
-            }
+            File.write("#{filename}", encrypted_output)
 
             nil
           end
-
         end
-
       end
     end
   end

data/lib/hiera/backend/eyaml/subcommands/unknown_command.rb

@@ -4,14 +4,12 @@ class Hiera
   module Backend
     module Eyaml
       module Subcommands
-
         class UnknownCommand < Eyaml::Subcommand
-
           class << self
             attr_accessor :original_command
           end
 
-          @@original_command = "unknown"
+          @@original_command = 'unknown'
 
           def self.options
             []
@@ -23,25 +21,23 @@ class Hiera
 
           def self.execute
             subcommands = Eyaml.subcommands
-            puts <<-EOS
-Unknown subcommand#{ ": " + Eyaml.subcommand if Eyaml.subcommand }
+            puts <<~EOS
+              Unknown subcommand#{': ' + Eyaml.subcommand if Eyaml.subcommand}
 
-Usage: eyaml <subcommand>
+              Usage: eyaml <subcommand>
 
-Please use one of the following subcommands or help for more help:
-  #{Eyaml.subcommands.sort.collect {|command|
-  command_class = Subcommands.const_get(Utils.camelcase command)
-  command unless command_class.hidden?
-}.compact.join(", ")}
-EOS
+              Please use one of the following subcommands or help for more help:
+                #{Eyaml.subcommands.sort.collect do |command|
+                    command_class = Subcommands.const_get(Utils.camelcase(command))
+                    command unless command_class.hidden?
+                  end.compact.join(', ')}
+            EOS
           end
 
           def self.hidden?
             true
           end
-
         end
-
       end
     end
   end

data/lib/hiera/backend/eyaml/subcommands/version.rb

@@ -5,15 +5,13 @@ class Hiera
   module Backend
     module Eyaml
       module Subcommands
-
         class Version < Subcommand
-
           def self.options
             []
           end
 
           def self.description
-            "show version information"
+            'show version information'
           end
 
           def self.execute
@@ -22,21 +20,18 @@ class Hiera
             Eyaml::LoggingHelper.info "hiera-eyaml (core): #{Eyaml::VERSION}"
 
             Plugins.plugins.each do |plugin|
-              plugin_shortname = plugin.name.split("hiera-eyaml-").last
+              plugin_shortname = plugin.name.split('hiera-eyaml-').last
               plugin_version = begin
                 Encryptor.find(plugin_shortname)::VERSION.to_s
-              rescue
-                "unknown (is plugin compatible with eyaml 2.0+ ?)"
+              rescue StandardError
+                'unknown (is plugin compatible with eyaml 2.0+ ?)'
               end
               Eyaml::LoggingHelper.info "hiera-eyaml-#{plugin_shortname} (gem): #{plugin_version}"
             end
 
             nil
-            
           end
-
         end
-
       end
     end
   end