vagrant-invade 0.5.5 → 0.6.0

data/lib/vagrant-invade/action/process.rb

@@ -0,0 +1,139 @@
+module VagrantPlugins
+  module Invade
+    module Action
+
+      include Vagrant::Action::Builtin
+
+      class Process
+
+        def initialize(app, env)
+          @app = app
+          @env = env
+
+          @validator = VagrantPlugins::Invade::Validator::Validator.new(env)
+          @generator = VagrantPlugins::Invade::Generator::Generator.new(env)
+
+          @logger = Log4r::Logger.new('vagrant::invade::action::validate')
+        end
+
+        def call(env)
+          config  = env[:invade]
+          quiet   = @env[:invade_validate_quiet]
+          generate = @env[:invade_generate]
+
+          invade_machine = Hash.new
+          invade_machine_part = Hash.new
+          invade_vagrantfile = Hash.new
+
+          ###############################################################
+          # Validate the settings and set default variables if needed
+          ###############################################################
+
+          # Remove empty Hashes
+          config.delete_blank
+
+          config.each do |config_key, config_data|
+
+            if config_key == 'machines'
+
+              # Iterate over machine configurations
+              config_data.each_with_index do |(machine, machine_part), _|
+
+                # Iterate over each machine part configuration
+                machine_part.each do |machine_part_name, machine_part_data|
+                  @env[:ui].info("\n[Invade][Machine: #{machine.upcase}]: Validating #{machine_part_name.upcase} part...") unless quiet
+
+                  # Is nested synced_folder, network, provision, or plugin part hash
+                  if machine_part_data.depth > 1
+
+                    invade_machine_part[machine_part_name] = ''
+                    machine_part_data.each do |value_name, value_data|
+
+                      # Output info message
+                      info_message = "\t#{machine_part_name.split('_').collect(&:capitalize).join}: #{value_name}"
+                      @env[:ui].info(info_message) unless @env[:invade_validate_quiet]
+
+                      # Exception handling for synced_folder and provision types
+                      if machine_part_name == 'synced_folder' or machine_part_name == 'provision'
+                        value_name = value_data['type']
+                        value_data.delete('type')
+                      end
+
+                      validated_data = validate(machine_part_name, value_name, value_data, machine_part_data.depth)
+                      invade_machine_part[machine_part_name].concat(
+                          generate(
+                              machine_name: machine,
+                              part: machine_part_name,
+                              part_type: value_name,
+                              data: validated_data,
+                              generator_type: Invade::Generator::Type::MACHINE_NESTED_PART
+                        )
+                      ) if generate
+                    end
+                  else # Is VM, or SSH part
+                    validated_data = validate('Machine', machine_part_name, machine_part_data, machine_part_data.depth)
+                    invade_machine_part[machine_part_name] = generate(
+                        machine_name: machine,
+                        part_type: machine_part_name,
+                        data: validated_data,
+                        generator_type: Invade::Generator::Type::MACHINE_PART
+                    ) if generate
+                  end
+                end
+
+                invade_machine[machine] = generate(
+                    machine_name: machine,
+                    data: invade_machine_part,
+                    generator_type: Invade::Generator::Type::MACHINE
+                )
+
+              end
+
+              invade_vagrantfile['machines'] = invade_machine
+              @env[:ui].success "\n[Invade]: Processed #{config_data.count} machine(s)."
+
+            else
+
+              # Info message
+              @env[:ui].info("\n[Invade]: Validating #{config_key.upcase} part...") unless quiet
+
+              validated_data = validate(config_key, config_key, config_data, config_data.depth)
+              invade_vagrantfile[config_key] = generate(
+                  part_type: config_key,
+                  data: validated_data,
+                  generator_type: Invade::Generator::Type::VAGRANT_PART
+              ) if generate
+
+            end
+
+          end
+
+          @env[:invade]['vagrantfile'] = generate(
+              data: invade_vagrantfile,
+              generator_type: Invade::Generator::Type::VAGRANTFILE
+          ) if generate
+
+          @env[:invade].delete('machines')
+
+          @app.call(env)
+        end
+
+        def validate(part_name, value_name, value_data, depth)
+          @validator.depth = depth
+          @validator.validate(part_name, value_name, value_data)
+        end
+
+        def generate(machine_name: nil, part: nil, part_type: nil, data: nil, generator_type: nil)
+          @generator.type = generator_type
+          @generator.generate(
+              machine: machine_name,
+              part: part,
+              type: part_type,
+              data: data
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-invade/action.rb

@@ -5,21 +5,19 @@ module VagrantPlugins
   module Invade
     module Action
 
-      # This middleware sequence will only validate the invade configuration file
-      def self.validate
+      def self.build
         Vagrant::Action::Builder.new.tap do |builder|
           builder.use Config
-          builder.use Validate
+          builder.use Process
+          builder.use Create
         end
       end
 
-      # This middleware sequence will validate and build the Vagrantfile
-      def self.build
+      # This middleware sequence will validate and build the invade configuration file
+      def self.process
         Vagrant::Action::Builder.new.tap do |builder|
           builder.use Config
-          builder.use Validate
-          builder.use Generate
-          builder.use Create
+          builder.use Process
         end
       end
 
@@ -30,13 +28,22 @@ module VagrantPlugins
         end
       end
 
+      def self.check
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use Config
+          builder.use Process
+          builder.use Check
+        end
+      end
+
       # The autoload farm
-      action_root = Pathname.new(File.expand_path("../action", __FILE__))
-      autoload :Init, action_root.join("init")
-      autoload :Config, action_root.join("config")
-      autoload :Validate, action_root.join("validate")
-      autoload :Generate, action_root.join("generate")
-      autoload :Create, action_root.join("create")
+      action_root = Pathname.new(File.expand_path('../action', __FILE__))
+      autoload :Init, action_root.join('init')
+      autoload :Config, action_root.join('config')
+      autoload :Process, action_root.join('process')
+      autoload :Create, action_root.join('create')
+      autoload :Check, action_root.join('check')
+
     end
   end
 end

data/lib/vagrant-invade/command/build.rb

@@ -8,25 +8,22 @@ module VagrantPlugins
         def execute
           options = {}
           opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant invade build [-f|--force] [-q|--quiet] [-h]"
-            o.separator ""
-            o.on("-f", "--force", "Overwrite existing Vagrantfile") do |f|
-              options[:force] = f
-            end
-            o.on("-q", "--quiet", "No verbose output.") do |q|
+            o.banner = 'Usage: vagrant invade build [-q|--quiet] [-h|--help]'
+            o.separator ''
+            o.on('-q', '--quiet', 'No verbose output.') do |q|
               options[:quiet] = q
             end
           end
 
           # Parse the options
           argv = parse_options(opts)
-          return if !argv
+          return unless argv
 
           # Validates InVaDE configuration
           action(Action.build, {
-            :invade_build_force => options[:force],
             :invade_build_quiet => options[:quiet],
-            :invade_validate_quiet => true # set this to true. Just build without validate output
+            :invade_validate_quiet => true,
+            :invade_generate => true
           })
 
           # Success, exit status 0

data/lib/vagrant-invade/command/check.rb

@@ -0,0 +1,33 @@
+require 'optparse'
+require_relative 'base'
+
+module VagrantPlugins
+  module Invade
+    module Command
+      class Check < Base
+        def execute
+          options = {}
+          opts = OptionParser.new do |o|
+            o.banner = 'Usage: vagrant invade check [-f|--force] [-q|--quiet] [-h|--help]'
+            o.separator ''
+            o.on('-q', '--quiet', 'No verbose output.') do |q|
+              options[:quiet] = q
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return unless argv
+
+          # Validates InVaDE configuration
+          action(Action.check, {
+            :invade_validate_quiet => true # set this to true. Just build without validate output
+          })
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-invade/command/init.rb

@@ -8,9 +8,9 @@ module VagrantPlugins
         def execute
           options = {}
           opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant invade init [-f|--force] [-h]"
-            o.separator ""
-            o.on("-f", "--force", "Force creating configuration file.") do |f|
+            o.banner = 'Usage: vagrant invade init [-f|--force] [-h]'
+            o.separator ''
+            o.on('-f', '--force', 'Force creating configuration file.') do |f|
               options[:force] = f
             end
           end

data/lib/vagrant-invade/command/root.rb

@@ -16,25 +16,31 @@ module VagrantPlugins
 
           # INIT COMMAND ("vagrant invade init")
             @subcommands.register(:init) do
-            require_relative "init"
+            require_relative 'init'
             Init
           end
 
+          # CHECK COMMAND ("vagrant invade check")
+            @subcommands.register(:check) do
+            require_relative 'check'
+            Check
+          end
+
           # VALIDATE COMMAND ("vagrant invade validate")
           @subcommands.register(:validate) do
-            require_relative "validate"
+            require_relative 'validate'
             Validate
           end
 
           # BUILD COMMAND ("vagrant invade build")
             @subcommands.register(:build) do
-            require_relative "build"
+            require_relative 'build'
             Build
           end
         end
 
         def execute
-          if @main_args.include?("-h") || @main_args.include?("--help")
+          if @main_args.include?('-h') || @main_args.include?('--help')
             # Print the help for all the sub-commands.
             return help
           end
@@ -52,9 +58,9 @@ module VagrantPlugins
         # Prints the help out for this command
         def help
           opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant invade <command> [<args>]"
-            o.separator ""
-            o.separator "Available subcommands:"
+            o.banner = 'Usage: vagrant invade <command> [<args>]'
+            o.separator ''
+            o.separator 'Available subcommands:'
 
             # Add the available subcommands as separators in order to print them
             # out as well.
@@ -65,8 +71,8 @@ module VagrantPlugins
               o.separator "     #{key}"
             end
 
-            o.separator ""
-            o.separator "For help on any individual command run `vagrant invade COMMAND -h`"
+            o.separator ''
+            o.separator 'For help on any individual command run `vagrant invade COMMAND -h`'
           end
 
           @env.ui.info(opts.help, prefix: false)

data/lib/vagrant-invade/command/validate.rb

@@ -8,24 +8,25 @@ module VagrantPlugins
         def execute
           options = {}
           opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant invade validate [-f|--force] [-q|--quiet] [-h]"
-            o.separator ""
-            o.on("-f", "--force", "Force replacing current Vagrantfile") do |f|
+            o.banner = 'Usage: vagrant invade validate [-f|--force] [-q|--quiet] [-h]'
+            o.separator ''
+            o.on('-f', '--force', 'Force replacing current Vagrantfile') do |f|
               options[:force] = f
             end
-            o.on("-q", "--quiet", "Just make it whisper.") do |q|
+            o.on('-q', '--quiet', 'Just make it whisper.') do |q|
               options[:quiet] = q
             end
           end
 
           # Parse the options
           argv = parse_options(opts)
-          return if !argv
+          return unless argv
 
           # Validates InVaDE configuration
-          action(Action.validate, {
+          action(Action.process, {
             :invade_validate_force => options[:force],
-            :invade_validate_quiet => options[:quiet]
+            :invade_validate_quiet => options[:quiet],
+            :invade_generate => false
           })
 
           # Success, exit status 0

data/lib/vagrant-invade/extend.rb

@@ -0,0 +1,24 @@
+class Hash
+  def depth
+      a = self.to_a
+      d = 1
+      while (a.flatten!(1).map! {|e| (e.is_a? Hash) ? e.to_a.flatten(1) : (e.is_a? Array) ? e : nil}.compact!.size > 0)
+          d += 1
+      end
+      d
+  end
+
+  def delete_blank
+    delete_if do |_, v|
+      (v.respond_to?(:empty?) ? v.empty? : !v) or v.instance_of?(Hash) && v.delete_blank.empty?
+    end
+  end
+end
+
+class Array
+  def depth
+    a = self.to_a
+    return 0 unless a.is_a?(Array)
+    return 1 + depth(a[0])
+  end
+end

data/lib/vagrant-invade/generator/type.rb

@@ -0,0 +1,15 @@
+module VagrantPlugins
+  module Invade
+    module Generator
+
+      class Type
+        VAGRANTFILE=0
+        VAGRANT_PART=1
+        MACHINE=2
+        MACHINE_PART=3
+        MACHINE_NESTED_PART=4
+      end
+
+    end
+  end
+end

data/lib/vagrant-invade/generator.rb

@@ -2,10 +2,54 @@ module VagrantPlugins
   module Invade
     module Generator
 
-      autoload :HostManager, 'vagrant-invade/generator/hostmanager'
-      autoload :MachinePart, 'vagrant-invade/generator/machine_part'
-      autoload :Machine, 'vagrant-invade/generator/machine'
-      autoload :Vagrantfile, 'vagrant-invade/generator/vagrantfile'
+      autoload :Type, 'vagrant-invade/generator/type'
+
+      class Generator
+
+        attr_accessor :type
+
+        def initialize(env)
+          @env = env
+          @type = Type::VAGRANT_PART
+
+          @logger = Log4r::Logger.new('vagrant::invade::generator::vagrant')
+        end
+        
+        def generate(machine: nil, part: nil, type: nil, data: nil)
+
+          begin
+
+            # Generates the templates with validated data
+            case @type
+              when Invade::Generator::Type::VAGRANTFILE
+                generated_data = InvadeModule::Invade::Vagrantfile.new(data).build
+
+              when Invade::Generator::Type::VAGRANT_PART
+                generator_class_name = type.split('_').collect(&:capitalize).join
+                generated_data = InvadeModule.const_get(generator_class_name).new(data).build
+
+              when Invade::Generator::Type::MACHINE
+                generated_data = InvadeModule::Invade::Machine.new(machine, data).build
+
+              when Invade::Generator::Type::MACHINE_NESTED_PART
+                type_formatted = type.split('_').collect(&:capitalize).join
+                part_formatted = part.split('_').collect(&:capitalize).join
+                generator_class_name = part_formatted + '::' + type_formatted
+                generated_data = InvadeModule.const_get(generator_class_name).new(machine, data).build
+
+              else
+                generator_class_name = type.split('_').collect(&:capitalize).join
+                generated_data = InvadeModule.const_get(generator_class_name).new(machine, data).build
+            end
+
+            return generated_data
+          rescue StandardError => e
+            @logger.error e
+            fail e
+          end
+        end
+
+      end
 
     end
   end