terraspace 0.0.0 → 0.1.0

data/lib/terraspace/compiler/dsl/syntax/tfvar.rb

@@ -0,0 +1,5 @@
+module Terraspace::Compiler::Dsl::Syntax
+  module Tfvar
+    include_dir("tfvar")
+  end
+end

data/lib/terraspace/compiler/dsl/syntax/tfvar/common.rb

@@ -0,0 +1,7 @@
+module Terraspace::Compiler::Dsl::Syntax::Tfvar
+  module Common
+    def tfvar(name, value)
+      @structure[name] = value
+    end
+  end
+end

data/lib/terraspace/compiler/dsl/tfvars.rb

@@ -0,0 +1,29 @@
+module Terraspace::Compiler::Dsl
+  class Tfvars < Base
+    include Terraspace::Compiler::Dsl::Syntax::Tfvar
+
+    # Can return nil if there's no tfvars declared
+    def build
+      evaluate(@src_path)
+      result = @structure.deep_stringify_keys
+      JSON.pretty_generate(result) unless result.empty?
+    end
+
+    def evaluate(path)
+      current_instance_vars = instance_variables
+      evaluate_file(path) # tfvar calls creates variables in @structure
+      new_instance_vars = instance_variables - current_instance_vars
+      add_instance_vars!(new_instance_vars)
+    end
+
+    def add_instance_vars!(new_instance_vars)
+      # IE: new_instance_variables = [:@cidr_block, :@name]
+      @structure.deep_stringify_keys!
+      new_instance_vars.each do |var|
+        key = var.to_s.sub('@','') # better to keep String as tfvar will usually use String notation, also deep_stringify_keys! earlier just in case
+        value = instance_variable_get(var)
+        @structure.merge!(key => value)
+      end
+    end
+  end
+end

data/lib/terraspace/compiler/erb/context.rb

@@ -0,0 +1,11 @@
+module Terraspace::Compiler::Erb
+  class Context
+    include Terraspace::Compiler::Dsl::Syntax::Mod
+
+    attr_reader :mod, :options
+    def initialize(mod)
+      @mod = mod
+      @options = mod.options # so user has access to cli options
+    end
+  end
+end

data/lib/terraspace/compiler/erb/render.rb

@@ -0,0 +1,12 @@
+module Terraspace::Compiler::Erb
+  class Render
+    def initialize(mod, src_path)
+      @mod, @src_path = mod, src_path
+    end
+
+    def build
+      context = Context.new(@mod)
+      RenderMePretty.result(@src_path, context: context)
+    end
+  end
+end

data/lib/terraspace/compiler/expander.rb

@@ -0,0 +1,19 @@
+module Terraspace::Compiler
+  class Expander
+    delegate :expand, :expand_string, to: :expander
+
+    attr_reader :expander
+    def initialize(mod, name)
+      @mod, @name = mod, name
+      @expander = expander_class.new(@mod)
+    end
+
+    def expander_class
+      # IE: TerraspacePluginAws::Interfaces::Expander
+      klass_name = Terraspace::Plugin.klass("Expander", backend: @name)
+      klass_name.constantize if klass_name
+    rescue NameError
+      Terraspace::Plugin::Expander::Generic
+    end
+  end
+end

data/lib/terraspace/compiler/strategy/abstract_base.rb

@@ -0,0 +1,7 @@
+module Terraspace::Compiler::Strategy
+  class AbstractBase
+    def initialize(mod, src_path)
+      @mod, @src_path = mod, src_path
+    end
+  end
+end

data/lib/terraspace/compiler/strategy/mod.rb

@@ -0,0 +1,15 @@
+module Terraspace::Compiler::Strategy
+  class Mod < AbstractBase
+    def run
+      ext = File.extname(@src_path).sub('.','')
+      klass = strategy_class(ext)
+      strategy = klass.new(@mod, @src_path) # IE: Terraspace::Compiler::Strategy::Mod::Rb.new
+      strategy.run
+    end
+
+    def strategy_class(ext)
+      return Mod::Pass if ext.empty? # infinite loop without this
+      "Terraspace::Compiler::Strategy::Mod::#{ext.camelize}".constantize rescue Mod::Pass
+    end
+  end
+end

data/lib/terraspace/compiler/strategy/mod/base.rb

@@ -0,0 +1,4 @@
+class Terraspace::Compiler::Strategy::Mod
+  class Base < Terraspace::Compiler::Strategy::AbstractBase
+  end
+end

data/lib/terraspace/compiler/strategy/mod/pass.rb

@@ -0,0 +1,7 @@
+class Terraspace::Compiler::Strategy::Mod
+  class Pass < Base
+    def run
+      File.open(@src_path) # return filehandle instead of content. Writer also handles
+    end
+  end
+end

data/lib/terraspace/compiler/strategy/mod/rb.rb

@@ -0,0 +1,7 @@
+class Terraspace::Compiler::Strategy::Mod
+  class Rb < Base
+    def run
+      Terraspace::Compiler::Dsl::Mod.new(@mod, @src_path).build
+    end
+  end
+end

data/lib/terraspace/compiler/strategy/mod/tf.rb

@@ -0,0 +1,7 @@
+class Terraspace::Compiler::Strategy::Mod
+  class Tf < Base
+    def run
+      Terraspace::Compiler::Erb::Render.new(@mod, @src_path).build
+    end
+  end
+end

data/lib/terraspace/compiler/strategy/tfvar.rb

@@ -0,0 +1,42 @@
+module Terraspace::Compiler::Strategy
+  class Tfvar
+    def initialize(mod)
+      @mod = mod
+      @order = 0
+    end
+
+    def run
+      layer_paths.each do |layer_path|
+        ext = File.extname(layer_path).sub('.','')
+        klass = strategy_class(ext)
+        next unless klass
+
+        strategy = klass.new(@mod, layer_path)
+        content = strategy.run
+
+        dest_name = ordered_name(layer_path)
+        writer = Terraspace::Compiler::Writer.new(@mod, dest_name: dest_name)
+        writer.write(content)
+      end
+    end
+
+    # Tact on number to ensure that tfvars will be processed in desired order.
+    # Also name auto.tfvars so it will automatically load
+    def ordered_name(layer_path)
+      @order += 1
+      prefix = @order.to_s.rjust(2, '0') # add leading 0 in case there are more than 10 layers
+      name = "#{prefix}-#{File.basename(layer_path)}"
+      name.sub('.tfvars','.auto.tfvars')
+          .sub('.rb','.auto.tfvars.json')
+    end
+
+    def layer_paths
+      Layer.new(@mod).paths
+    end
+
+    def strategy_class(ext)
+      "Terraspace::Compiler::Strategy::Tfvar::#{ext.camelize}".constantize
+    rescue NameError
+    end
+  end
+end

data/lib/terraspace/compiler/strategy/tfvar/base.rb

@@ -0,0 +1,4 @@
+class Terraspace::Compiler::Strategy::Tfvar
+  class Base < Terraspace::Compiler::Strategy::AbstractBase
+  end
+end

data/lib/terraspace/compiler/strategy/tfvar/layer.rb

@@ -0,0 +1,110 @@
+class Terraspace::Compiler::Strategy::Tfvar
+  class Layer
+    def initialize(mod)
+      @mod = mod
+    end
+
+    def paths
+      layer_paths = layers.map do |layer|
+        [
+          "#{tfvars_dir}/#{layer}.tfvars",
+          "#{tfvars_dir}/#{layer}.rb",
+        ]
+      end.flatten
+
+      layer_paths.select do |path|
+        File.exist?(path)
+      end
+    end
+
+    # Layers in order
+    #
+    #     Name / Pattern                 | Example
+    #     -------------------------------|---------------
+    #     base                           | base.tfvars
+    #     env                            | dev.tfvars
+    #     region/base                    | us-west-2/base.tfvars (provider specific)
+    #     region/env                     | us-west-2/dev.tfvars (provider specific)
+    #     namespace/base                 | 112233445566/base.tfvars (provider specific)
+    #     namespace/env                  | 112233445566/dev.tfvars (provider specific)
+    #     namespace/region/base          | 112233445566/us-west-2/base.tfvars (provider specific)
+    #     namespace/region/env           | 112233445566/us-west-2/dev.tfvars (provider specific)
+    #     provider/base                  | aws/base.tfvars (provider specific)
+    #     provider/env                   | aws/dev.tfvars (provider specific)
+    #     provider/region/base           | aws/us-west-2/base.tfvars (provider specific)
+    #     provider/region/env            | aws/us-west-2/dev.tfvars (provider specific)
+    #     provider/namespace/base        | aws/112233445566/base.tfvars (provider specific)
+    #     provider/namespace/env         | aws/112233445566/dev.tfvars (provider specific)
+    #     provider/namespace/region/base | aws/112233445566/us-west-2/base.tfvars (provider specific)
+    #     provider/namespace/region/env  | aws/112233445566/us-west-2/dev.tfvars (provider specific)
+    #
+    # namespace and region depends on the provider. Here an example of the mapping:
+    #
+    #              | AWS     | Azure        | Google
+    #    ----------|---------|--------------|-------
+    #    namespace | account | subscription | project
+    #    region    | region  | location     | region
+    #
+    #
+    def layers
+      layer_levels + plugin_layers
+    end
+
+    def plugin_layers
+      layers = []
+      Terraspace::Plugin.layer_classes.each do |klass|
+        layer = klass.new
+
+        # region is high up because its simpler and the more common case is a single provider
+        layers += layer_levels(layer.region)
+
+        # namespace is a simple way keep different tfvars between different engineers on different accounts
+        layers += layer_levels(layer.namespace)
+        layers += layer_levels("#{layer.namespace}/#{layer.region}")
+
+        # in case using multiple providers and one region
+        layers += layer_levels(layer.provider)
+        layers += layer_levels("#{layer.provider}/#{layer.region}") # also in case another provider has colliding regions
+
+        # Most general layering
+        layers += layer_levels("#{layer.provider}/#{layer.namespace}")
+        layers += layer_levels("#{layer.provider}/#{layer.namespace}/#{layer.region}")
+      end
+      layers
+    end
+
+    # adds prefix and to each layer pair that has base and Terraspace.env. IE:
+    #
+    #    "#{prefix}/base"
+    #    "#{prefix}/#{Terraspace.env}"
+    #
+    def layer_levels(prefix=nil)
+      levels = ["base", Terraspace.env, @mod.instance] # layer levels
+      env_levels = levels.map { |l| "#{Terraspace.env}/#{l}" } # env folder also
+      levels = levels + env_levels
+      levels.map do |i|
+        [prefix, i].compact.join('/')
+      end
+    end
+
+    # seed dir takes higher precedence than the tfvars folder within the stack module. Example:
+    #
+    #     seed/tfvars/stacks/demo (folder must have *.tfvars or *.rb files)
+    #     app/stacks/demo/tfvars
+    #
+    # This allows user to take over the tfvars embedded in the stack if they need to. Generally,
+    # putting tfvars in within the app/stacks/MOD/tfvars folder seems cleaner and easier to follow.
+    #
+    # Will also consider app/modules/demo/tfvars. Though modules to be reuseable and stacks is where business logic
+    # should go.
+    #
+    def tfvars_dir
+      seed_dir = "#{Terraspace.root}/seed/tfvars/#{@mod.build_dir(disable_instance: true)}"
+      mod_dir = "#{@mod.root}/tfvars"
+
+      empty = Dir.glob("#{seed_dir}/*").empty?
+      empty ? mod_dir : seed_dir
+    end
+
+  end
+end

data/lib/terraspace/compiler/strategy/tfvar/rb.rb

@@ -0,0 +1,7 @@
+class Terraspace::Compiler::Strategy::Tfvar
+  class Rb < Base
+    def run
+      Terraspace::Compiler::Dsl::Tfvars.new(@mod, @src_path).build
+    end
+  end
+end

data/lib/terraspace/compiler/strategy/tfvar/tfvars.rb

@@ -0,0 +1,7 @@
+class Terraspace::Compiler::Strategy::Tfvar
+  class Tfvars < Base
+    def run
+      Terraspace::Compiler::Erb::Render.new(@mod, @src_path).build
+    end
+  end
+end

data/lib/terraspace/compiler/writer.rb

@@ -0,0 +1,36 @@
+module Terraspace::Compiler
+  class Writer
+    include Basename
+    include Terraspace::Util
+
+    def initialize(mod, options={})
+      @mod, @options = mod, options
+      @src_path = options[:src_path]
+      @dest_name = options[:dest_name] # override generated name
+    end
+
+    def dest_path
+      name = @dest_name || @src_path.sub('.rb','.tf.json')
+      name = basename(name)
+      "#{dest_dir}/#{name}"
+    end
+
+    def dest_dir
+      if @mod.is_a?(Terraspace::Mod::Remote)
+        File.dirname(@src_path) # for Mod::Remote src is dest
+      else
+        @mod.cache_build_dir
+      end
+    end
+
+    def write(content)
+      FileUtils.mkdir_p(File.dirname(dest_path))
+      if content.respond_to?(:path) # IO filehandle
+        FileUtils.cp(content.path, dest_path) # preserves permission
+      else # just content
+        IO.write(dest_path, content)
+      end
+      logger.debug "Created #{Terraspace::Util.pretty_path(dest_path)}"
+    end
+  end
+end

data/lib/terraspace/completer.rb

@@ -0,0 +1,159 @@
+=begin
+Code Explanation:
+
+There are 3 types of things to auto-complete:
+
+  1. command: the command itself
+  2. parameters: command parameters.
+  3. options: command options
+
+Here's an example:
+
+  mycli hello name --from me
+
+  * command: hello
+  * parameters: name
+  * option: --from
+
+When command parameters are done processing, the remaining completion words will be options.  We can tell that the command params are completed based on the method arity.
+
+## Arity
+
+For example, say you had a method for a CLI command with the following form:
+
+  ufo scale service count --cluster dev
+
+It's equivalent ruby method:
+
+  scale(service, count) = has an arity of 2
+
+So typing:
+
+  ufo scale service count [TAB] # there are 3 parameters including the "scale" command according to Thor's CLI processing.
+
+So the completion should only show options, something like this:
+
+  --noop --verbose --cluster
+
+## Splat Arguments
+
+When the ruby method has a splat argument, it's arity is negative.  Here are some example methods and their arities.
+
+   ship(service) = 1
+   scale(service, count) = 2
+   ships(*services) = -1
+   foo(example, *rest) = -2
+
+Fortunately, negative and positive arity values are processed the same way. So we take simply take the absolute value of the arity and process it the same.
+
+Here are some test cases, hit TAB after typing the command:
+
+  terraspace completion
+  terraspace completion hello
+  terraspace completion hello name
+  terraspace completion hello name --
+  terraspace completion hello name --noop
+
+  terraspace completion
+  terraspace completion sub:goodbye
+  terraspace completion sub:goodbye name
+
+## Subcommands and Thor::Group Registered Commands
+
+Sometimes the commands are not simple thor commands but are subcommands or Thor::Group commands. A good specific example is the ufo tool.
+
+  * regular command: ufo ship
+  * subcommand: ufo docker
+  * Thor::Group command: ufo init
+
+Auto-completion accounts for each of these type of commands.
+=end
+module Terraspace
+  class Completer
+    def initialize(command_class, *params)
+      @params = params
+      @current_command = @params[0]
+      @command_class = command_class # CLI initiall
+    end
+
+    def run
+      if subcommand?(@current_command)
+        subcommand_class = @command_class.subcommand_classes[@current_command]
+        @params.shift # destructive
+        Completer.new(subcommand_class, *@params).run # recursively use subcommand
+        return
+      end
+
+      # full command has been found!
+      unless found?(@current_command)
+        puts all_commands
+        return
+      end
+
+      # will only get to here if command aws found (above)
+      arity = @command_class.instance_method(@current_command).arity.abs
+      if @params.size > arity or thor_group_command?
+        puts options_completion
+      else
+        puts params_completion
+      end
+    end
+
+    def subcommand?(command)
+      @command_class.subcommands.include?(command)
+    end
+
+    # hacky way to detect that command is a registered Thor::Group command
+    def thor_group_command?
+      command_params(raw=true) == [[:rest, :args]]
+    end
+
+    def found?(command)
+      public_methods = @command_class.public_instance_methods(false)
+      command && public_methods.include?(command.to_sym)
+    end
+
+    # all top-level commands
+    def all_commands
+      commands = @command_class.all_commands.reject do |k,v|
+        v.is_a?(Thor::HiddenCommand)
+      end
+      commands.keys
+    end
+
+    def command_params(raw=false)
+      params = @command_class.instance_method(@current_command).parameters
+      # Example:
+      # >> Sub.instance_method(:goodbye).parameters
+      # => [[:req, :name]]
+      # >>
+      raw ? params : params.map!(&:last)
+    end
+
+    def params_completion
+      offset = @params.size - 1
+      offset_params = command_params[offset..-1]
+      command_params[offset..-1].first
+    end
+
+    def options_completion
+      used = ARGV.select { |a| a.include?('--') } # so we can remove used options
+
+      method_options = @command_class.all_commands[@current_command].options.keys
+      class_options = @command_class.class_options.keys
+
+      all_options = method_options + class_options + ['help']
+
+      all_options.map! { |o| "--#{o.to_s.gsub('_','-')}" }
+      filtered_options = all_options - used
+      filtered_options.uniq
+    end
+
+    # Useful for debugging. Using puts messes up completion.
+    def log(msg)
+      File.open("/tmp/complete.log", "a") do |file|
+        file.puts(msg)
+      end
+    end
+  end
+end