hiera-eyaml 3.4.0 → 4.0.0

data/lib/hiera/backend/eyaml/plugins.rb

@@ -4,16 +4,15 @@ class Hiera
   module Backend
     module Eyaml
       class Plugins
-
         @@plugins = []
         @@commands = []
         @@options = []
 
-        def self.register_options args
-          options = args[ :options ]
-          plugin = args[ :plugin ]
+        def self.register_options(args)
+          options = args[:options]
+          plugin = args[:plugin]
           options.each do |name, option_hash|
-            new_option = {:name => "#{plugin}_#{name}"}
+            new_option = { name: "#{plugin}_#{name}" }
             new_option.merge! option_hash
             @@options << new_option
           end
@@ -24,38 +23,35 @@ class Hiera
         end
 
         def self.find
-
           gem_version = Gem::Version.new(Gem::VERSION)
           this_version = Gem::Version.create(Hiera::Backend::Eyaml::VERSION)
-          index = gem_version >= Gem::Version.new("1.8.0") ? Gem::Specification : Gem.source_index
+          index = (gem_version >= Gem::Version.new('1.8.0')) ? Gem::Specification : Gem.source_index
 
           [index].flatten.each do |source|
-            specs = gem_version >= Gem::Version.new("1.6.0") ? source.latest_specs(true) : source.latest_specs
+            specs = (gem_version >= Gem::Version.new('1.6.0')) ? source.latest_specs(true) : source.latest_specs
 
             specs.each do |spec|
               spec = spec.to_spec if spec.respond_to?(:to_spec)
               next if @@plugins.include? spec
 
-              dependency = spec.dependencies.find { |d| d.name == "hiera-eyaml" }
-              next if dependency && !dependency.requirement.satisfied_by?( this_version )
+              dependency = spec.dependencies.find { |d| d.name == 'hiera-eyaml' }
+              next if dependency && !dependency.requirement.satisfied_by?(this_version)
 
               file = nil
-              if gem_version >= Gem::Version.new("1.8.0")
-                file = spec.matches_for_glob("**/eyaml_init.rb").first
-              else
-                file = Gem.searcher.matching_files(spec, "**/eyaml_init.rb").first
-              end
+              file = if gem_version >= Gem::Version.new('1.8.0')
+                       spec.matches_for_glob('**/eyaml_init.rb').first
+                     else
+                       Gem.searcher.matching_files(spec, '**/eyaml_init.rb').first
+                     end
 
               next unless file
 
               @@plugins << spec
               load file
             end
-
           end
 
           @@plugins
-
         end
 
         def self.plugins
@@ -65,7 +61,6 @@ class Hiera
         def self.commands
           @@commands
         end
-
       end
     end
   end

data/lib/hiera/backend/eyaml/subcommand.rb

@@ -5,55 +5,69 @@ require 'yaml'
 class Hiera
   module Backend
     module Eyaml
-
       class Subcommand
-
         class << self
           attr_accessor :global_options, :options, :helptext
         end
 
         @@global_options = [
-           {:name          => :encrypt_method,
-              :description => "Override default encryption and decryption method (default is PKCS7)", 
-              :short       => 'n', 
-              :default     => "pkcs7"},
-           {:name          => :version,
-              :description => "Show version information"},
-           {:name          => :verbose,
-              :description => "Be more verbose",
-              :short       => 'v'},
-           {:name          => :trace,
-              :description => "Enable trace debug",
-              :short       => 't'},
-           {:name          => :quiet,
-              :description => "Be less verbose",
-              :short       => 'q'},
-           {:name          => :help,
-              :description => "Information on how to use this command",
-              :short       => 'h'}
-          ]
-        
+          { name: :encrypt_method,
+            description: 'Override default encryption and decryption method (default is PKCS7)',
+            short: 'n',
+            default: 'pkcs7', },
+          { name: :version,
+            description: 'Show version information', },
+          { name: :verbose,
+            description: 'Be more verbose',
+            short: 'v', },
+          { name: :trace,
+            description: 'Enable trace debug',
+            short: 't', },
+          { name: :quiet,
+            description: 'Be less verbose',
+            short: 'q', },
+          { name: :help,
+            description: 'Information on how to use this command',
+            short: 'h', },
+        ]
+
         def self.load_config_file
-          config = { :options => {}, :sources => [] }
-          [ "/etc/eyaml/config.yaml", "#{ENV['HOME']}/.eyaml/config.yaml", "#{ENV['EYAML_CONFIG']}" ].each do |config_file|
+          config = { options: {}, sources: [] }
+
+          config_paths = []
+          # Global
+          config_paths += ['/etc/eyaml/config.yaml']
+          # Home directory
+          env_home = ENV.fetch('HOME', nil)
+          config_paths += ["#{env_home}/.eyaml/config.yaml"] if env_home
+          # Relative to current directory
+          config_paths += ['.eyaml/config.yaml']
+          # Explicit ENV variable.
+          env_eyaml_config = ENV.fetch('EYAML_CONFIG', nil)
+          config_paths += [env_eyaml_config] if env_eyaml_config
+
+          # Load each path and stack configs.
+          config_paths.each do |config_file|
+            next unless config_file and File.file? config_file
+
             begin
               yaml_contents = YAML.load_file(config_file)
               config[:options].merge! yaml_contents
               config[:sources].push(config_file)
-            rescue 
+            rescue StandardError
               raise StandardError, "Could not open config file \"#{config_file}\" for reading"
-            end if config_file and File.file? config_file
+            end
           end
           config
         end
 
-        def self.all_options 
+        def self.all_options
           options = @@global_options.dup
           options += self.options if self.options
           options += Plugins.options
           # merge in defaults from configuration files
-          config_file = self.load_config_file
-          options.map!{ | opt| 
+          config_file = load_config_file
+          options.map!  do |opt|
             key_name = "#{opt[:name]}"
             if config_file[:options].has_key? key_name
               opt[:default] = config_file[:options][key_name]
@@ -61,106 +75,90 @@ class Hiera
             else
               opt
             end
-          }
-          { :options => options, :sources => config_file[:sources] || [] }
+          end
+          { options: options, sources: config_file[:sources] || [] }
         end
 
-        def self.attach_option opt
+        def self.attach_option(opt)
           self.suboptions += opt
         end
 
-        def self.find commandname = "unknown_command"
+        def self.find(commandname = 'unknown_command')
           begin
             require "hiera/backend/eyaml/subcommands/#{commandname.downcase}"
           rescue Exception => e
-            require "hiera/backend/eyaml/subcommands/unknown_command"
+            require 'hiera/backend/eyaml/subcommands/unknown_command'
             return Hiera::Backend::Eyaml::Subcommands::UnknownCommand
-          end          
-          command_module = Module.const_get('Hiera').const_get('Backend').const_get('Eyaml').const_get('Subcommands')
-          command_class = Utils.find_closest_class :parent_class => command_module, :class_name => commandname
+          end
+          command_module = Module.const_get(:Hiera).const_get(:Backend).const_get(:Eyaml).const_get(:Subcommands)
+          command_class = Utils.find_closest_class parent_class: command_module, class_name: commandname
           command_class || Hiera::Backend::Eyaml::Subcommands::UnknownCommand
         end
 
         def self.parse
-
           me = self
-          all = self.all_options
+          all = all_options
 
-          options = Optimist::options do
-
-            version "Hiera-eyaml version " + Hiera::Backend::Eyaml::VERSION.to_s
-            banner ["eyaml #{me.prettyname}: #{me.description}", me.helptext, "Options:"].compact.join("\n\n")
+          options = Optimist.options do
+            version 'Hiera-eyaml version ' + Hiera::Backend::Eyaml::VERSION.to_s
+            banner ["eyaml #{me.prettyname}: #{me.description}", me.helptext, 'Options:'].compact.join("\n\n")
 
             all[:options].each do |available_option|
-
-              skeleton = {:description => "",
-                          :short => :none}
+              skeleton = { description: '',
+                           short: :none, }
 
               skeleton.merge! available_option
-              opt skeleton[:name], 
-                  skeleton[:desc] || skeleton[:description],  #legacy plugins 
-                  :short => skeleton[:short], 
-                  :default => skeleton[:default], 
-                  :type => skeleton[:type]
-
+              opt skeleton[:name],
+                  skeleton[:desc] || skeleton[:description], # legacy plugins
+                  short: skeleton[:short],
+                  default: skeleton[:default],
+                  type: skeleton[:type]
             end
 
             stop_on Eyaml.subcommands
-
           end
 
-          if options[:verbose]
-            Hiera::Backend::Eyaml.verbosity_level += 1
-          end
+          Hiera::Backend::Eyaml.verbosity_level += 1 if options[:verbose]
 
-          if options[:trace]
-            Hiera::Backend::Eyaml.verbosity_level += 2
-          end
+          Hiera::Backend::Eyaml.verbosity_level += 2 if options[:trace]
 
-          if options[:quiet]
-            Hiera::Backend::Eyaml.verbosity_level = 0
-          end
+          Hiera::Backend::Eyaml.verbosity_level = 0 if options[:quiet]
 
-          if options[:encrypt_method]
-            Hiera::Backend::Eyaml.default_encryption_scheme = options[:encrypt_method]
-          end
+          Hiera::Backend::Eyaml.default_encryption_scheme = options[:encrypt_method] if options[:encrypt_method]
 
           if all[:sources]
             all[:sources].each do |source|
-              LoggingHelper::debug "Loaded config from #{source}"
+              LoggingHelper.debug "Loaded config from #{source}"
             end
           end
 
           options
-
         end
 
-        def self.validate args
+        def self.validate(args)
           args
         end
 
         def self.description
-          "no description"
+          'no description'
         end
 
         def self.helptext
-          "Usage: eyaml #{self.prettyname} [options]"
+          "Usage: eyaml #{prettyname} [options]"
         end
 
         def self.execute
-          raise StandardError, "This command is not implemented yet (#{self.to_s.split('::').last})"
+          raise StandardError, "This command is not implemented yet (#{to_s.split('::').last})"
         end
 
         def self.prettyname
-          Utils.snakecase self.to_s.split('::').last
+          Utils.snakecase to_s.split('::').last
         end
 
         def self.hidden?
           false
         end
-
       end
-
     end
   end
 end

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

@@ -4,15 +4,13 @@ class Hiera
   module Backend
     module Eyaml
       module Subcommands
-
         class Createkeys < Subcommand
-
-          def self.options 
+          def self.options
             []
           end
 
           def self.description
-            "create a set of keys with which to encrypt/decrypt eyaml data"
+            'create a set of keys with which to encrypt/decrypt eyaml data'
           end
 
           def self.execute
@@ -20,9 +18,7 @@ class Hiera
             encryptor.create_keys
             nil
           end
-
         end
-
       end
     end
   end

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

@@ -8,48 +8,45 @@ class Hiera
   module Backend
     module Eyaml
       module Subcommands
-
         class Decrypt < Subcommand
-
           def self.options
-            [{: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 => :eyaml,
-              :description => "Source input is an eyaml file",
-              :short => 'e',
-              :type => :string},
-             {:name => :stdin,
-              :description => "Source input is taken from stdin",
-              :short => :none}
-            ]
+            [{ 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: :eyaml,
+               description: 'Source input is an eyaml file',
+               short: 'e',
+               type: :string, },
+             { name: :stdin,
+               description: 'Source input is taken from stdin',
+               short: :none, },]
           end
 
           def self.description
-            "decrypt some data"
+            'decrypt some data'
           end
 
-          def self.validate options
-            sources = [:eyaml, :password, :string, :file, :stdin].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[eyaml password string file stdin].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 :stdin
-              STDIN.read
-            when :string
-              options[:string]
-            when :file
-              File.read options[:file]
-            when :eyaml
-              File.read options[:eyaml]
-            end
+                                   when :stdin
+                                     STDIN.read
+                                   when :string
+                                     options[:string]
+                                   when :file
+                                     File.read options[:file]
+                                   when :eyaml
+                                     File.read options[:eyaml]
+                                   end
             options
           end
 
@@ -57,31 +54,34 @@ class Hiera
             parser = Parser::ParserFactory.encrypted_parser
             tokens = parser.parse(Eyaml::Options[:input_data])
             case Eyaml::Options[:source]
-              when :eyaml
-                decrypted = tokens.map{ |token| token.to_decrypted }
-                decrypted.join
-              else
-                yamled = false
-                decrypted = tokens.map{ |token|
-                  case token.class.name
-                    when /::EncToken$/
-                      if (yamled) then
-                        yamled = false
-                        token.to_plain_text.match(/[\r\n]/) ? "|\n  " + token.to_plain_text.gsub(/([\r\n]+)/, '\1  ') : token.to_plain_text
-                      else
-                        token.to_plain_text
-                      end
+            when :eyaml
+              decrypted = tokens.map { |token| token.to_decrypted }
+              decrypted.join
+            else
+              yamled = false
+              decrypted = tokens.map do |token|
+                case token.class.name
+                when /::EncToken$/
+                  if yamled
+                    yamled = false
+                    if /[\r\n]/.match?(token.to_plain_text)
+                      "|\n  " + token.to_plain_text.gsub(/([\r\n]+)/,
+                                                         '\1  ')
                     else
-                      yamled = true
-                      token.match
+                      token.to_plain_text
+                    end
+                  else
+                    token.to_plain_text
                   end
-                }
-                decrypted.join
+                else
+                  yamled = true
+                  token.match
+                end
+              end
+              decrypted.join
             end
           end
-
         end
-
       end
     end
   end