terraspace 0.0.0 → 0.2.1

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_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

data/lib/terraspace/completer/script.rb

@@ -0,0 +1,6 @@
+class Terraspace::Completer::Script
+  def self.generate
+    bash_script = File.expand_path("script.sh", File.dirname(__FILE__))
+    logger.info "source #{bash_script}"
+  end
+end

data/lib/terraspace/completer/script.sh

@@ -0,0 +1,10 @@
+_terraspace() {
+  COMPREPLY=()
+  local word="${COMP_WORDS[COMP_CWORD]}"
+  local words=("${COMP_WORDS[@]}")
+  unset words[0]
+  local completion=$(terraspace completion ${words[@]})
+  COMPREPLY=( $(compgen -W "$completion" -- "$word") )
+}
+
+complete -F _terraspace terraspace

data/lib/terraspace/core.rb

@@ -0,0 +1,52 @@
+module Terraspace
+  module Core
+    extend Memoist
+
+    def env
+      ENV['TS_ENV'] || "dev"
+    end
+    memoize :env
+
+    @@root = nil
+    def root
+      @@root ||= ENV['TS_ROOT'] || Dir.pwd
+    end
+
+    # allow testing frameworks to switch roots
+    def root=(v)
+      @@root = v
+    end
+
+    def cache_root
+      ENV['TS_CACHE_ROOT'] || config.build.cache_root || "#{root}/.terraspace-cache"
+    end
+    memoize :cache_root
+
+    def tmp_root
+      ENV['TS_TMP_ROOT'] || "/tmp/terraspace"
+    end
+    memoize :tmp_root
+
+    def configure(&block)
+      App.instance.configure(&block)
+    end
+
+    # Generally, use the Terraspace.config instead of App.instance.config since it guarantees the load_project_config call
+    def config
+      App.instance.load_project_config
+      App.instance.config
+    end
+    memoize :config
+
+    def logger
+      config.logger
+    end
+    memoize :logger
+
+    def check_project!
+      return if File.exist?("#{Terraspace.root}/config/app.rb")
+      logger.error "ERROR: It doesnt look like this is a terraspace project. Are you sure you are in a terraspace project?".color(:red)
+      ENV['TS_TEST'] ? raise : exit(1)
+    end
+  end
+end

data/lib/terraspace/ext.rb

@@ -0,0 +1,2 @@
+require_relative "ext/bundler"
+require_relative "ext/core/module"