hiera-eyaml 1.3.8 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0794eaaca28f7702c08e251f54f938c06c7856fe
-  data.tar.gz: 505eea5b6e2bc567f5587adabb3c0aaef8b701e2
+  metadata.gz: a8965f033228e9d0c47c6ec9e7b2a399b76ead46
+  data.tar.gz: 222599950c2668eb59e99f42ad0b19cf1693d0c1
 SHA512:
-  metadata.gz: b995c5e993985e4d38c0b1dfe55c0767057311cf00c75b3d3ac12538dfe7d58a9343a949005f06ccb1d1ea10628ffea2bf13e770d3ea5dad1288e2e09ba30174
-  data.tar.gz: b54b10584df24f60bf148bd62116e9c6b6426e67be16a4c95172b2e1776cd33a30b308dba0a17a7814ceac84268749a35737567147605714e63e85b7ac6f8fbd
+  metadata.gz: 8ed7968fd5f5cb756bebcdcf82c8e3cc7c2284feb0e10d37e68e03f09daf1935f4fe71c48868b4119fe5b8240661a61c92f13f4bbc2066333508bef6b0b39621
+  data.tar.gz: a586ad0604541e2639c1e20f3fd1d72ac2099df0f57c962350536e43f0a97265456412a926651ca20592bbef1cd5a259488136ad12eaafe1de74924e1e2d6ec7

data/.gitignore

@@ -5,3 +5,4 @@ keys/*.pem
 pkg/
 tmp/
 .DS_Store
+.rvmrc

data/Gemfile.lock

@@ -19,9 +19,9 @@ GEM
     ffi (1.9.3)
     gherkin (2.12.2)
       multi_json (~> 1.3)
-    hiera (1.2.1)
+    hiera (1.3.0)
       json_pure
-    hiera-eyaml-plaintext (0.5)
+    hiera-eyaml-plaintext (0.6)
     highline (1.6.20)
     json_pure (1.8.1)
     multi_json (1.8.2)

data/README.md

@@ -6,6 +6,7 @@ Hiera eyaml
 hiera-eyaml is a backend for Hiera that provides per-value encryption of sensitive data within yaml files 
 to be used by Puppet.
 
+:new: *v2.0 - commandline tool syntax has changed, see below for details*
 
 Advantages over hiera-gpg
 -------------------------
@@ -46,7 +47,7 @@ encrypted-property: >
     IZGeunzwhqfmEtGiqpvJJQ5wVRdzJVpTnANBA5qxeA==]
 ```
 
-To edit this you can use the command `eyaml -i important.eyaml` which will decrypt the file, fire up an editor with
+To edit this you can use the command `eyaml edit important.eyaml` which will decrypt the file, fire up an editor with
 the decrypted values and re-encrypt any edited values when you exit the editor. This tool makes editing your encrypted
 files as simple as clear text files.
 
@@ -62,7 +63,7 @@ Setup
 
 The first step is to create a pair of keys:
 
-    $ eyaml -c
+    $ eyaml createkeys
 
 This creates a public and private key with default names in the default location. (./keys)
 
@@ -90,13 +91,13 @@ The permissions for this folder should allow the puppet user (normally 'puppet')
 
 To encrypt something, you only need the public_key, so distribute that to people creating hiera properties
 
-    $ eyaml -e -f filename            # Encrypt a file
-    $ eyaml -e -s 'hello there'       # Encrypt a string
-    $ eyaml -e -p                     # Encrypt a password (prompt for it)
+    $ eyaml encrypt -f filename            # Encrypt a file
+    $ eyaml encrypt -s 'hello there'       # Encrypt a string
+    $ eyaml encrypt -p                     # Encrypt a password (prompt for it)
 
 Use the -l parameter to pass in a label for the encrypted value,
 
-    $ eyaml -e -l 'some_easy_to_use_label' -s 'yourSecretString' --pkcs7-private-key /etc/puppet/secure/keys/private_key.pkcs7.pem --pkcs7-public-key /etc/puppet/secure/keys/public_key.pkcs7.pem
+    $ eyaml encrypt -l 'some_easy_to_use_label' -s 'yourSecretString'
 
 
 ### Decryption
@@ -105,8 +106,8 @@ To decrypt something, you need the public_key and the private_key.
 
 To test decryption you can also use the eyaml tool if you have both keys
 
-    $ eyaml -d -f filename               # Decrypt a file
-    $ eyaml -d -s 'ENC[PKCS7,.....]'     # Decrypt a string
+    $ eyaml decrypt -f filename               # Decrypt a file
+    $ eyaml decrypt -s 'ENC[PKCS7,.....]'     # Decrypt a string
 
 ### Editing eyaml files
 
@@ -115,7 +116,7 @@ you can edit the encrypted values in place, using the special edit mode of the e
 mode opens a decrypted copy of the eyaml file in your `$EDITOR` and will encrypt and modified values
 when you exit the editor.
 
-    $ eyaml -i filename.eyaml         # Edit an eyaml file in place
+    $ eyaml edit filename.eyaml         # Edit an eyaml file in place
 
 When editing eyaml files, you will see that the unencrypted plaintext is marked to allow the eyaml tool to 
 identify each encrypted block, along with the encryption method. This is used to make sure that the block 
@@ -312,4 +313,4 @@ Authors
 - [Tom Poulton](http://github.com/TomPoulton) - Initial author. eyaml backend.
 - [Geoff Meakin](http://github.com/gtmtech) - Major contributor. eyaml command, tests, CI
 - [Simon Hildrew](http://github.com/sihil) - Contributor. eyaml edit sub command.
-- [Robert Fielding](http://github.com/rooprob) - Contributor. eyaml recrypt sub command.
+- [Robert Fielding](http://github.com/rooprob) - Contributor. eyaml recrypt sub command.

data/lib/hiera/backend/eyaml.rb

@@ -2,11 +2,20 @@ class Hiera
   module Backend
     module Eyaml
 
+      VERSION = "2.0.0"
+      DESCRIPTION = "Hiera-eyaml is a backend for Hiera which provides OpenSSL encryption/decryption for Hiera properties"
+
       class RecoverableError < StandardError
       end
 
-      VERSION = "1.3.8"
+      def self.subcommand= command
+        @@subcommand = command
+      end
 
+      def self.subcommand
+        @@subcommand
+      end
+      
       def self.default_encryption_scheme= new_encryption
         @@default_encryption_scheme = new_encryption
       end
@@ -16,6 +25,23 @@ class Hiera
         @@default_encryption_scheme
       end
 
+      def self.verbosity_level= new_verbosity_level
+        @@debug_level = new_verbosity_level
+      end
+
+      def self.verbosity_level
+        @@debug_level ||= 1
+        @@debug_level
+      end
+
+      def self.subcommands= commands
+        @@subcommands = commands
+      end
+
+      def self.subcommands
+        @@subcommands
+      end
+      
     end
   end
 end

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

@@ -1,13 +1,9 @@
 require 'trollop'
 require 'hiera/backend/eyaml'
 require 'hiera/backend/eyaml/utils'
-require 'hiera/backend/eyaml/actions/createkeys_action'
-require 'hiera/backend/eyaml/actions/decrypt_action'
-require 'hiera/backend/eyaml/actions/encrypt_action'
-require 'hiera/backend/eyaml/actions/recrypt_action'
-require 'hiera/backend/eyaml/actions/edit_action'
 require 'hiera/backend/eyaml/plugins'
 require 'hiera/backend/eyaml/options'
+require 'hiera/backend/eyaml/subcommand'
 
 class Hiera
   module Backend
@@ -16,87 +12,27 @@ class Hiera
 
         def self.parse
 
-          options = Trollop::options do
-
-            version "Hiera-eyaml version " + Hiera::Backend::Eyaml::VERSION.to_s
-            banner <<-EOS
-Hiera-eyaml is a backend for Hiera which provides OpenSSL encryption/decryption for Hiera properties
-
-Usage:
-  eyaml [options]
-  eyaml -i file.eyaml       # edit a file
-  eyaml -e -s some-string   # encrypt a string
-  eyaml -e -p               # encrypt a password
-  eyaml -e -f file.txt      # encrypt a file
-  cat file.txt | eyaml -e   # encrypt a file on a pipe
-
-Options:
-  EOS
-
-            opt :createkeys, "Create public and private keys for use encrypting properties", :short => 'c'
-            opt :decrypt, "Decrypt something", :short => 'd'
-            opt :encrypt, "Encrypt something", :short => 'e'
-            opt :recrypt, "Recrypt something", :short => 'r', :type => :string
-            opt :edit, "Decrypt, Edit, and Reencrypt", :short => 'i', :type => :string
-            opt :eyaml, "Source input is an eyaml file", :short => 'y', :type => :string
-            opt :password, "Source input is a password entered on the terminal", :short => 'p'
-            opt :string, "Source input is a string provided as an argument", :short => 's', :type => :string
-            opt :file, "Source input is a file", :short => 'f', :type => :string
-            opt :stdin, "Source input is taken from stdin", :short => :none
-            opt :encrypt_method, "Override default encryption and decryption method (default is PKCS7)", :short => 'n', :default => "pkcs7"
-            opt :output, "Output format of final result (examples, block, string)", :type => :string, :short => 'o', :default => "examples"
-            opt :label, "Apply a label to the encrypted result", :short => 'l', :type => :string
-            opt :debug, "Be more verbose", :short => :none
-            opt :quiet, "Be less verbose", :short => :none
-
-            Hiera::Backend::Eyaml::Plugins.options.each do |name, option|
-              opt name, option[:desc], :type => option[:type], :short => option[:short], :default => option[:default]
-            end
-
+          Utils.require_dir 'hiera/backend/eyaml/subcommands'
+          Eyaml.subcommands = Utils.find_all_subclasses_of({ :parent_class => Hiera::Backend::Eyaml::Subcommands }).collect {|classname| Utils.snakecase classname}
+
+          Eyaml.subcommand = ARGV.shift
+          subcommand = case Eyaml.subcommand
+          when nil
+            ARGV.delete_if {true}
+            "unknown_command"
+          when /^\-/
+            ARGV.delete_if {true}
+            "help"
+          else
+            Eyaml.subcommand
           end
 
-          actions = [:createkeys, :decrypt, :recrypt, :encrypt, :edit].collect {|x| x if options[x]}.compact
-          sources = [:edit, :recrypt, :eyaml, :password, :string, :file, :stdin].collect {|x| x if options[x]}.compact
-          # sources << :stdin if STDIN
+          command_class = Subcommand.find subcommand
 
-          Trollop::die "You can only specify one of (#{actions.join(', ')})" if actions.count > 1
-          Trollop::die "You can only specify one of (#{sources.join(', ')})" if sources.count > 1
-          Trollop::die "Creating keys does not require a source to encrypt/decrypt" if actions.first == :createkeys and sources.count > 0
+          options = command_class.parse
+          options[:executor] = command_class
 
-          options[:source] = sources.first
-          options[:action] = actions.first
-          options[:source] = :not_applicable if options[:action] == :createkeys
-
-          Trollop::die "Nothing to do" if options[:source].nil? or options[:action].nil?
-
-          options[:input_data] = case options[:source]
-          when :stdin
-            STDIN.read
-          when :password
-            Utils.read_password
-          when :string
-            options[:string]
-          when :file
-            File.read options[:file]
-          when :eyaml
-            File.read options[:eyaml]
-          when :stdin
-            STDIN.read
-          else
-            if options[:edit]
-              options[:eyaml] = options[:edit]
-              options[:source] = :eyaml
-              File.read options[:edit]
-            elsif options[:recrypt]
-              options[:eyaml] = options[:recrypt]
-              options[:source] = :eyaml
-              File.read options[:recrypt]
-            else
-              nil
-            end
-          end
-
-          Eyaml.default_encryption_scheme = options[:encrypt_method].upcase if options[:encrypt_method]
+          options = command_class.validate options
           Eyaml::Options.set options
           Eyaml::Options.debug
 
@@ -104,11 +40,14 @@ Options:
 
         def self.execute
 
-          action = Eyaml::Options[:action]
-          action_class = Module.const_get('Hiera').const_get('Backend').const_get('Eyaml').const_get('Actions').const_get("#{Utils.camelcase action.to_s}Action")
-
-          return_value = action_class.execute
-          puts return_value unless return_value.nil?
+          executor = Eyaml::Options[:executor]
+          begin
+            result = executor.execute
+            puts result unless result.nil?
+          rescue Exception => e
+            Utils.warn e.message
+            Utils.info e.backtrace.inspect
+          end
 
         end
 

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

@@ -0,0 +1,21 @@
+require 'rubygems'
+
+class Hiera
+  module Backend
+    module Eyaml
+      class Commands
+
+        @@commands = []
+
+        def self.register
+          
+        end
+
+        def self.commands
+          @@commands
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 require 'base64'
+require 'hiera/backend/eyaml/utils'
 
 class Hiera
   module Backend
@@ -15,7 +16,7 @@ class Hiera
           encryption_scheme = Eyaml.default_encryption_scheme if encryption_scheme.nil?
           require "hiera/backend/eyaml/encryptors/#{encryption_scheme.downcase}"          
           encryptor_module = Module.const_get('Hiera').const_get('Backend').const_get('Eyaml').const_get('Encryptors')
-          encryptor_class = self.find_closest_class :parent_class => encryptor_module, :class_name => encryption_scheme
+          encryptor_class = Utils.find_closest_class :parent_class => encryptor_module, :class_name => encryption_scheme
           raise StandardError, "Could not find hiera-eyaml encryptor: #{encryption_scheme}. Try gem install hiera-eyaml-#{encryption_scheme.downcase} ?" if encryptor_class.nil?
           encryptor_class
         end
@@ -50,23 +51,8 @@ class Hiera
             Eyaml::Options[ "#{plugin_classname}_#{name}" ] || self.options[ "#{plugin_classname}_#{name}" ]
           end
 
-          def self.find_closest_class args
-            parent_class = args[ :parent_class ]
-            class_name = args[ :class_name ]
-            constants = parent_class.constants
-            candidates = []
-            constants.each do | candidate |
-              candidates << candidate.to_s if candidate.to_s.downcase == class_name.downcase
-            end
-            if candidates.count > 0
-              parent_class.const_get candidates.first
-            else
-              nil
-            end
-          end
-
           def self.hiera?
-            "hiera".eql? Eyaml::Options[:source]
+            Utils::hiera?
           end
 
           def self.format_message msg
@@ -74,19 +60,15 @@ class Hiera
           end
 
           def self.debug msg
-            if self.hiera?
-              Hiera.debug format_message msg
-            else
-              Utils::debug format_message msg
-            end
+            Utils::debug :from => plugin_classname, :msg => msg
+          end
+
+          def self.info msg
+            Utils::info :from => plugin_classname, :msg => msg
           end
 
           def self.warn msg
-            if self.hiera?
-              Hiera.warn format_message msg
-            else
-              Utils::info format_message msg
-            end
+            Utils::warn :from => plugin_classname, :msg => msg
           end
 
       end

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

@@ -24,9 +24,9 @@ class Hiera
           Utils::debug "Dump of eyaml tool options dict:"
           Utils::debug "--------------------------------"
           @@options.each do |k, v|
-            Utils::debug "#{k.class.name}:#{k} = #{v.class.name}:#{v}"
+            Utils::debug sprintf "%18s %-18s = %-18s %-18s", "(#{k.class.name})", k.to_s, v.to_s, "(#{v.class.name})"
           end
-          Utils::debug ""
+          Utils::debug "--------------------------------"
         end
 
       end

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

@@ -6,13 +6,16 @@ class Hiera
       class Plugins
 
         @@plugins = []
-        @@options = {}
+        @@commands = []
+        @@options = []
 
         def self.register_options args
-          options_hash = args[ :options ]
+          options = args[ :options ]
           plugin = args[ :plugin ]
-          options_hash.each do |key, value|
-            @@options.merge!({ "#{plugin}_#{key}" => value })
+          options.each do |name, option_hash|
+            new_option = {:name => "#{plugin}_#{name}"}
+            new_option.merge! option_hash
+            @@options << new_option
           end
         end
 
@@ -31,8 +34,6 @@ class Hiera
             specs.each do |spec|
               next if @@plugins.include? spec
 
-              # If this gem depends on Vagrant, verify this is a valid release of
-              # Vagrant for this gem to load into.
               dependency = spec.dependencies.find { |d| d.name == "hiera-eyaml" }
               next if dependency && !dependency.requirement.satisfied_by?( this_version )
 
@@ -59,6 +60,10 @@ class Hiera
           @@plugins
         end
 
+        def self.commands
+          @@commands
+        end
+
       end
     end
   end

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

@@ -0,0 +1,126 @@
+require 'base64'
+# require 'hiera/backend/eyaml/subcommands/unknown_command'
+
+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          => :quiet,
+              :description => "Be less verbose",
+              :short       => 'q'},
+           {:name          => :help,
+              :description => "Information on how to use this command",
+              :short       => 'h'}
+          ]
+        
+        def self.all_options 
+          options = @@global_options.dup
+          options += self.options if self.options
+          options += Plugins.options
+          options
+        end
+
+        def self.attach_option opt
+          self.suboptions += opt
+        end
+
+        def self.find commandname = "unknown_command"
+          begin
+            require "hiera/backend/eyaml/subcommands/#{commandname.downcase}"
+          rescue Exception => e
+            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
+          command_class || Hiera::Backend::Eyaml::Subcommands::UnknownCommand
+        end
+
+        def self.parse
+
+          me = self
+
+          options = Trollop::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")
+
+            me.all_options.each do |available_option|
+
+              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]
+
+            end
+
+            stop_on Eyaml.subcommands
+
+          end
+
+          if options[:verbose]
+            Hiera::Backend::Eyaml.verbosity_level += 1
+          end
+
+          if options[:quiet]
+            Hiera::Backend::Eyaml.verbosity_level = 0
+          end
+
+          if options[:encrypt_method]
+            Hiera::Backend::Eyaml.default_encryption_scheme = options[:encrypt_method]
+          end
+
+          options
+
+        end
+
+        def self.validate args
+          args
+        end
+
+        def self.description
+          "no description"
+        end
+
+        def self.helptext
+          "Usage: eyaml #{self.prettyname} [options]"
+        end
+
+        def self.execute
+          raise StandardError, "This command is not implemented yet (#{self.to_s.split('::').last})"
+        end
+
+        def self.prettyname
+          Utils.snakecase self.to_s.split('::').last
+        end
+
+        def self.hidden?
+          false
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'hiera/backend/eyaml/subcommand'
+
+class Hiera
+  module Backend
+    module Eyaml
+      module Subcommands
+
+        class Createkeys < Subcommand
+
+          def self.options 
+            []
+          end
+
+          def self.description
+            "create a set of keys with which to encrypt/decrypt eyaml data"
+          end
+
+          def self.execute
+            encryptor = Encryptor.find Eyaml.default_encryption_scheme
+            encryptor.create_keys
+            nil
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require 'hiera/backend/eyaml'
+require 'hiera/backend/eyaml/utils'
+require 'hiera/backend/eyaml/options'
+require 'hiera/backend/eyaml/parser/parser'
+require 'hiera/backend/eyaml/subcommand'
+
+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}
+            ]
+          end
+
+          def self.description
+            "decrypt some data"
+          end
+
+          def self.validate options
+            sources = [:eyaml, :password, :string, :file, :stdin].collect {|x| x if options[x]}.compact
+            Trollop::die "You must specify a source" if sources.count.zero?
+            Trollop::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
+            options
+          end
+
+          def self.execute
+            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
+                decrypted = tokens.map{ |token|
+                  case token.class.name
+                    when /::EncToken$/
+                      token.plain_text
+                    else
+                      token.match
+                  end
+                }
+                decrypted.join
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/hiera/backend/eyaml/{actions/edit_action.rb → subcommands/edit.rb}

@@ -1,19 +1,37 @@
 require 'hiera/backend/eyaml/utils'
-require 'hiera/backend/eyaml/actions/decrypt_action'
-require 'hiera/backend/eyaml/actions/encrypt_action'
 require 'hiera/backend/eyaml/options'
 require 'hiera/backend/eyaml/parser/parser'
+require 'hiera/backend/eyaml/subcommand'
 require 'highline/import'
 
 class Hiera
   module Backend
     module Eyaml
-      module Actions
-  
-        class EditAction
+      module Subcommands
 
-          def self.execute 
+        class Edit < Subcommand
 
+          def self.options
+            []
+          end
+
+          def self.description
+            "edit an eyaml file"
+          end
+
+          def self.helptext
+            "Usage: eyaml edit [options] <some-eyaml-file>"
+          end
+
+          def self.validate options
+            Trollop::die "You must specify an eyaml file" if ARGV.empty?
+            options[:source] = :eyaml
+            options[:eyaml] = ARGV.shift
+            options[:input_data] = File.read options[:eyaml]
+            options
+          end
+
+          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
@@ -30,7 +48,6 @@ class Hiera
 
               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?
 
               if edited_file == decrypted_input

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

@@ -0,0 +1,100 @@
+require 'hiera/backend/eyaml/options'
+require 'hiera/backend/eyaml/parser/parser'
+require 'hiera/backend/eyaml/parser/encrypted_tokens'
+require 'hiera/backend/eyaml/subcommand'
+
+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}
+            ]
+          end
+
+          def self.description
+            "encrypt some data"
+          end
+
+          def self.validate options
+            sources = [:password, :string, :file, :stdin, :eyaml].collect {|x| x if options[x]}.compact
+            Trollop::die "You must specify a source" if sources.count.zero?
+            Trollop::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
+              Utils.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
+              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
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'hiera/backend/eyaml/subcommand'
+require 'hiera/backend/eyaml'
+
+class Hiera
+  module Backend
+    module Eyaml
+      module Subcommands
+
+        class Help < Subcommand
+
+          def self.options
+            []
+          end
+
+          def self.description
+            "this page"
+          end
+
+          def self.execute
+
+            puts <<-EOS
+Welcome to eyaml #{Eyaml::VERSION} 
+
+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")}
+
+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
+          end
+
+          def self.hidden?
+            true
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/hiera/backend/eyaml/{actions/recrypt_action.rb → subcommands/recrypt.rb}

@@ -1,30 +1,42 @@
-require 'hiera/backend/eyaml/utils'
-require 'hiera/backend/eyaml/actions/decrypt_action'
-require 'hiera/backend/eyaml/actions/encrypt_action'
+require 'hiera/backend/eyaml/subcommand'
 require 'hiera/backend/eyaml/options'
 require 'hiera/backend/eyaml/parser/parser'
 
 class Hiera
   module Backend
     module Eyaml
-      module Actions
+      module Subcommands
 
-        class RecryptAction
+        class Recrypt < Subcommand
 
-          def self.execute
+          def self.options
+            []
+          end
+
+          def self.description
+            "recrypt an eyaml file"
+          end
+
+          def self.helptext
+            "Usage: eyaml recrypt [options] <some-eyaml-file>"
+          end
+
+          def self.validate options
+            Trollop::die "You must specify an eyaml file" if ARGV.empty?
+            options[:source] = :eyaml
+            options[:eyaml] = ARGV.shift
+            options[:input_data] = File.read options[:eyaml]
+            options
+          end
+
+          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_file = Utils.write_tempfile decrypted_input
-
-            edited_file = File.read decrypted_file
-            Utils.secure_file_delete :file => decrypted_file, :num_bytes => [edited_file.length, decrypted_input.length].max
-
-            raise StandardError, "Edited file is blank" if edited_file.empty?
 
             decrypted_parser = Parser::ParserFactory.decrypted_parser
-            edited_tokens = decrypted_parser.parse(edited_file)
+            edited_tokens = decrypted_parser.parse(decrypted_input)
 
             encrypted_output = edited_tokens.map{ |t| t.to_encrypted }.join
 

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

@@ -0,0 +1,48 @@
+require 'hiera/backend/eyaml/subcommand'
+
+class Hiera
+  module Backend
+    module Eyaml
+      module Subcommands
+
+        class UnknownCommand < Eyaml::Subcommand
+
+          class << self
+            attr_accessor :original_command
+          end
+
+          @@original_command = "unknown"
+
+          def self.options
+            []
+          end
+
+          def self.description
+            "Unknown command (#{@@original_command})"
+          end
+
+          def self.execute
+            subcommands = Eyaml.subcommands
+            puts <<-EOS
+Unknown subcommand#{ ": " + Eyaml.subcommand if 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
+          end
+
+          def self.hidden?
+            true
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'hiera/backend/eyaml/subcommand'
+require 'hiera/backend/eyaml'
+
+class Hiera
+  module Backend
+    module Eyaml
+      module Subcommands
+
+        class Version < Subcommand
+
+          def self.options
+            []
+          end
+
+          def self.description
+            "show version information"
+          end
+
+          def self.execute
+            plugin_versions = {}
+
+            puts <<-EOS
+Version info
+
+hiera-eyaml (core): #{Eyaml::VERSION}
+EOS
+
+            Plugins.plugins.each do |plugin|
+              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+ ?)"
+              end
+              puts "    hiera-eyaml-#{plugin_shortname} (gem): #{plugin_version}"
+            end
+
+            nil
+            
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -25,6 +25,11 @@ class Hiera
           string.split('_').map{|e| e.capitalize}.join
         end
 
+        def self.snakecase string
+          return string if string !~ /[A-Z]/
+          string.split(/(?=[A-Z])/).collect {|x| x.downcase}.join("_")
+        end
+
         def self.find_editor
           editor = ENV['EDITOR']
           editor ||= %w{ /usr/bin/sensible-editor /usr/bin/editor /usr/bin/vim /usr/bin/vi }.collect {|e| e if FileTest.executable? e}.compact.first
@@ -46,7 +51,9 @@ class Hiera
         def self.write_tempfile data_to_write
           file = Tempfile.open('eyaml_edit')
           path = file.path
+          file.close!
 
+          file = File.open(path, "w")
           file.puts data_to_write
           file.close
 
@@ -80,12 +87,83 @@ class Hiera
 
         end
 
-        def self.info message
-          STDERR.puts message unless Eyaml::Options[:quiet]
+        def self.find_closest_class args
+          parent_class = args[ :parent_class ]
+          class_name = args[ :class_name ]
+          constants = parent_class.constants
+          candidates = []
+          constants.each do | candidate |
+            candidates << candidate.to_s if candidate.to_s.downcase == class_name.downcase
+          end
+          if candidates.count > 0
+            parent_class.const_get candidates.first
+          else
+            nil
+          end
+        end
+
+        def self.require_dir classdir
+          num_class_hierarchy_levels = self.to_s.split("::").count - 1 
+          root_folder = File.dirname(__FILE__) + "/" + Array.new(num_class_hierarchy_levels).fill("..").join("/")
+          class_folder = root_folder + "/" + classdir
+          Dir[File.expand_path("#{class_folder}/*.rb")].uniq.each do |file|
+            # puts "Requiring file: #{file}"
+            require file
+          end
+        end
+
+        def self.find_all_subclasses_of args
+          parent_class = args[ :parent_class ]
+          constants = parent_class.constants
+          candidates = []
+          constants.each do | candidate |
+            candidates << candidate.to_s.split('::').last if parent_class.const_get(candidate).class.to_s == "Class"
+          end
+          candidates
+        end 
+
+        def self.hiera?
+          "hiera".eql? Eyaml::Options[:source]
+        end
+
+        def self.structure_message messageinfo
+          message = {:from => "hiera-eyaml-core"}
+          case messageinfo.class.to_s
+          when 'Hash'
+            message.merge!(messageinfo)
+          else
+            message.merge!({:msg => messageinfo.to_s})
+          end
+        end
+
+        def self.warn messageinfo
+          message = self.structure_message messageinfo
+          message = "[#{message[:from]}] !!! #{message[:msg]}"
+          if self.hiera?
+            Hiera.warn format_message msg
+          else
+            STDERR.puts message
+          end
         end
 
-        def self.debug message
-          STDERR.puts message if Eyaml::Options[:debug]
+        def self.info messageinfo
+          message = self.structure_message messageinfo
+          message = "[#{message[:from]}] #{message[:msg]}"
+          if self.hiera?
+            Hiera.debug message if Eyaml.verbosity_level > 0
+          else
+            STDERR.puts message if Eyaml.verbosity_level > 0
+          end
+        end
+
+        def self.debug messageinfo
+          message = self.structure_message messageinfo
+          message = "[#{message[:from]}] #{message[:msg]}"
+          if self.hiera?
+            Hiera.debug message if Eyaml.verbosity_level > 1
+          else
+            STDERR.puts message if Eyaml.verbosity_level > 1
+          end
         end
 
       end

data/lib/hiera/backend/eyaml_backend.rb

@@ -1,6 +1,6 @@
 require 'hiera/backend/eyaml/encryptor'
-require 'hiera/backend/eyaml/actions/decrypt_action'
 require 'hiera/backend/eyaml/utils'
+require 'hiera/backend/eyaml/options'
 require 'hiera/backend/eyaml/parser/parser'
 require 'yaml'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hiera-eyaml
 version: !ruby/object:Gem::Version
-  version: 1.3.8
+  version: 2.0.0
 platform: ruby
 authors:
 - Tom Poulton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-25 00:00:00.000000000 Z
+date: 2013-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trollop
@@ -57,11 +57,7 @@ files:
 - hiera-eyaml.gemspec
 - lib/hiera/backend/eyaml.rb
 - lib/hiera/backend/eyaml/CLI.rb
-- lib/hiera/backend/eyaml/actions/createkeys_action.rb
-- lib/hiera/backend/eyaml/actions/decrypt_action.rb
-- lib/hiera/backend/eyaml/actions/edit_action.rb
-- lib/hiera/backend/eyaml/actions/encrypt_action.rb
-- lib/hiera/backend/eyaml/actions/recrypt_action.rb
+- lib/hiera/backend/eyaml/commands.rb
 - lib/hiera/backend/eyaml/encryptor.rb
 - lib/hiera/backend/eyaml/encryptors/pkcs7.rb
 - lib/hiera/backend/eyaml/options.rb
@@ -69,6 +65,15 @@ files:
 - lib/hiera/backend/eyaml/parser/parser.rb
 - lib/hiera/backend/eyaml/parser/token.rb
 - lib/hiera/backend/eyaml/plugins.rb
+- lib/hiera/backend/eyaml/subcommand.rb
+- lib/hiera/backend/eyaml/subcommands/createkeys.rb
+- lib/hiera/backend/eyaml/subcommands/decrypt.rb
+- lib/hiera/backend/eyaml/subcommands/edit.rb
+- lib/hiera/backend/eyaml/subcommands/encrypt.rb
+- lib/hiera/backend/eyaml/subcommands/help.rb
+- lib/hiera/backend/eyaml/subcommands/recrypt.rb
+- lib/hiera/backend/eyaml/subcommands/unknown_command.rb
+- lib/hiera/backend/eyaml/subcommands/version.rb
 - lib/hiera/backend/eyaml/utils.rb
 - lib/hiera/backend/eyaml_backend.rb
 - sublime_text/README.md

data/lib/hiera/backend/eyaml/actions/createkeys_action.rb

@@ -1,24 +0,0 @@
-require 'hiera/backend/eyaml/utils'
-require 'hiera/backend/eyaml/options'
-
-class Hiera
-  module Backend
-    module Eyaml
-      module Actions
-
-        class CreatekeysAction
-
-          def self.execute
-
-            encryptor = Encryptor.find Eyaml.default_encryption_scheme
-            encryptor.create_keys
-            nil
-
-          end
-
-        end
-
-      end
-    end
-  end
-end

data/lib/hiera/backend/eyaml/actions/decrypt_action.rb

@@ -1,39 +0,0 @@
-require 'hiera/backend/eyaml'
-require 'hiera/backend/eyaml/utils'
-require 'hiera/backend/eyaml/options'
-require 'hiera/backend/eyaml/parser/parser'
-
-class Hiera
-  module Backend
-    module Eyaml
-      module Actions
-
-        class DecryptAction
-
-          def self.execute
-            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
-                decrypted = tokens.map{ |token|
-                  case token.class.name
-                    when /::EncToken$/
-                      token.plain_text
-                    else
-                      token.match
-                  end
-                }
-                decrypted.join
-            end
-
-          end
-
-        end
-
-      end
-    end
-  end
-end

data/lib/hiera/backend/eyaml/actions/encrypt_action.rb

@@ -1,41 +0,0 @@
-require 'hiera/backend/eyaml/options'
-require 'hiera/backend/eyaml/parser/parser'
-require 'hiera/backend/eyaml/parser/encrypted_tokens'
-
-class Hiera
-  module Backend
-    module Eyaml
-      module Actions
-        class EncryptAction
-
-          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
-              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
-            end
-          end
-
-        end
-      end
-    end
-  end
-end