lono 3.5.0 → 4.0.0

data/lib/lono/cfn/create.rb

@@ -1,3 +1,5 @@
+require "yaml"
+
 class Lono::Cfn::Create < Lono::Cfn::Base
   # save_stack is the interface method
   def save_stack(params)
@@ -23,13 +25,15 @@ class Lono::Cfn::Create < Lono::Cfn::Base
     end
 
     template_body = IO.read(@template_path)
-    cfn.create_stack(
+    params = {
       stack_name: @stack_name,
       template_body: template_body,
       parameters: params,
       capabilities: capabilities, # ["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"]
       disable_rollback: !@options[:rollback],
-    )
+    }
+    show_parameters(params, "cfn.create_stack")
+    cfn.create_stack(params)
     puts message unless @options[:mute]
   end
 

data/lib/lono/cfn/delete.rb

@@ -1,5 +1,5 @@
 class Lono::Cfn::Delete
-  include Lono::Cfn::AwsServices
+  include Lono::Cfn::AwsService
   include Lono::Cfn::Util
 
   def initialize(stack_name, options={})
@@ -12,7 +12,7 @@ class Lono::Cfn::Delete
     if @options[:noop]
       puts "NOOP #{message}"
     else
-      are_you_sure?(:delete)
+      are_you_sure?(@stack_name, :delete)
 
       if stack_exists?(@stack_name)
         cfn.delete_stack(stack_name: @stack_name)

data/lib/lono/cfn/diff.rb

@@ -1,5 +1,5 @@
 class Lono::Cfn::Diff < Lono::Cfn::Base
-  include Lono::Cfn::AwsServices
+  include Lono::Cfn::AwsService
 
   def run
     unless stack_exists?(@stack_name)

data/lib/lono/cfn/preview.rb

@@ -20,29 +20,40 @@ class Lono::Cfn::Preview < Lono::Cfn::Base
       puts "WARN: Cannot create a change set for the stack because the #{@stack_name} does not exists.".colorize(:yellow)
       return false
     end
-    exist_unless_updatable(stack_status(@stack_name))
+    exit_unless_updatable!(stack_status(@stack_name))
 
     template_body = IO.read(@template_path)
+    params = {
+      change_set_name: change_set_name,
+      stack_name: @stack_name,
+      template_body: template_body,
+      parameters: params,
+      capabilities: capabilities, # ["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"]
+    }
+    show_parameters(params, "cfn.create_change_set")
     begin
-      cfn.create_change_set(
-        change_set_name: change_set_name,
-        stack_name: @stack_name,
-        template_body: template_body,
-        parameters: params,
-        capabilities: capabilities, # ["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"]
-      )
+      cfn.create_change_set(params)
     rescue Aws::CloudFormation::Errors::ValidationError => e
-      if e.message =~ /^Parameters: /
-        puts "Error creating CloudFormation preview because invalid CloudFormation parameters. Full error message:".colorize(:red)
-        puts e.message
-        quit(1)
-      else
-        raise
-      end
+      handle_error(e)
     end
     true
   end
 
+  # Example errors:
+  # "Template error: variable names in Fn::Sub syntax must contain only alphanumeric characters, underscores, periods, and colons"
+  def handle_error(e)
+    raise if ENV['FULL_BACKTRACE']
+
+    if e.message =~ /^Parameters: / || e.message =~ /^Template error: /
+      puts "Error creating CloudFormation preview because invalid CloudFormation parameters. Full error message:".colorize(:red)
+      puts e.message
+      puts "For full backtrace run command again with FULL_BACKTRACE=1"
+      quit(1)
+    else
+      raise
+    end
+  end
+
   def display_change_set
     print "Generating CloudFormation Change Set for preview.."
     change_set = describe_change_set

data/lib/lono/cfn/update.rb

@@ -16,12 +16,12 @@ class Lono::Cfn::Update < Lono::Cfn::Base
       puts "Cannot update a stack because the #{@stack_name} does not exists."
       return
     end
-    exist_unless_updatable(stack_status(@stack_name))
+    exit_unless_updatable!(stack_status(@stack_name))
 
     error = nil
     diff.run if @options[:diff]
     preview.run if @options[:preview]
-    are_you_sure?(:update)
+    are_you_sure?(@stack_name, :update)
 
     if @options[:change_set] # defaults to this
       message << " via change set: #{preview.change_set_name}"
@@ -34,14 +34,16 @@ class Lono::Cfn::Update < Lono::Cfn::Base
 
   def standard_update(params)
     template_body = IO.read(@template_path)
+    params = {
+      stack_name: @stack_name,
+      template_body: template_body,
+      parameters: params,
+      capabilities: capabilities, # ["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"]
+      disable_rollback: !@options[:rollback],
+    }
+    show_parameters(params, "cfn.update_stack")
     begin
-      cfn.update_stack(
-        stack_name: @stack_name,
-        template_body: template_body,
-        parameters: params,
-        capabilities: capabilities, # ["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"]
-        disable_rollback: !@options[:rollback],
-      )
+      cfn.update_stack(params)
     rescue Aws::CloudFormation::Errors::ValidationError => e
       puts "ERROR: #{e.message}".red
       error = true

data/lib/lono/cfn/util.rb

@@ -1,13 +1,13 @@
 module Lono::Cfn::Util
-  def are_you_sure?(action)
+  def are_you_sure?(stack_name, action)
     if @options[:sure]
       sure = 'y'
     else
       message = case action
       when :update
-        "Are you sure you want to want to update the stack with the changes? (y/N)"
+        "Are you sure you want to want to update the '#{stack_name}' stack with the changes? (y/N)"
       when :delete
-        "Are you sure you want to want to delete the stack? (y/N)"
+        "Are you sure you want to want to delete the '#{stack_name}' stack? (y/N)"
       end
       puts message
       sure = $stdin.gets

data/lib/lono/clean.rb

@@ -9,6 +9,6 @@ class Lono::Clean
   def run
     puts "Cleaning up"
     puts "Removing output/ folder"
-    FileUtils.rm_rf("#{Lono.root}/output")
+    FileUtils.rm_rf("#{Lono.config.output_path}")
   end
 end

data/lib/lono/cli.rb

@@ -1,63 +1,95 @@
-require 'thor'
-require 'lono/command'
-
 module Lono
-  autoload :Help, 'lono/help'
-  class CLI < Lono::Command
-
-    desc "new [NAME]", "Generates lono starter project"
-    long_desc Help.new_long_desc
-    option :force, type: :boolean, aliases: "-f", desc: "override existing starter files"
-    option :quiet, type: :boolean, aliases: "-q", desc: "silence the output"
-    option :format, type: :string, default: "yaml", desc: "starter project template format: json or yaml"
-    def new(project_root)
-      Lono::New.new(options.clone.merge(project_root: project_root)).run
-    end
-
-    desc "import [SOURCE]", "Imports raw CloudFormation template and lono-fies it"
-    long_desc Help.import
-    option :format, type: :string, default: "yaml", desc: "format for the final template"
-    option :casing, default: "underscore", desc: "camelcase or underscore the template name"
-    option :name, default: nil, desc: "final name of downloaded template without extension"
+  class CLI < Command
+
+    long_desc Help.text(:new)
+    New.cli_options.each do |args|
+      option *args
+    end
+    register(New, "new", "new NAME", "generates new CLI project")
+
+    desc "import SOURCE", "Imports raw CloudFormation template and lono-fies it"
+    long_desc Help.text(:import)
+    option :name, required: true, default: nil, desc: "final name of downloaded template without extension"
+    option :summary, default: true, type: :boolean, desc: "provide template summary after import"
     def import(source)
       Importer.new(source, options).run
     end
 
     desc "generate", "Generate both CloudFormation templates and parameters files"
-    Help.generate
-    option :clean, type: :boolean, aliases: "-c", desc: "remove all output files before generating"
-    option :quiet, type: :boolean, aliases: "-q", desc: "silence the output"
-    option :pretty, type: :boolean, default: true, desc: "json pretty the output.  only applies with json format"
+    long_desc Help.text(:generate)
+    option :clean, type: :boolean, default: true, desc: "remove all output files before generating"
+    option :quiet, type: :boolean, desc: "silence the output"
     def generate
-      puts "Generating both CloudFormation template and parameter files."
-      Lono::Template::DSL.new(options.clone).run
-      Lono::Param::Generator.generate_all(options.clone)
+      puts "Generating CloudFormation templates, parameters, and scripts"
+      Script::Build.new(options).run
+      Template::DSL.new(options).run
+      Param::Generator.generate_all(options)
+    end
+
+    desc "user_data NAME", "Generates user_data script for debugging"
+    long_desc Help.text(:user_data)
+    option :clean, type: :boolean, default: true, desc: "remove all output/user_data files before generating"
+    def user_data(name)
+      Script::Build.new(options).run
+      UserData.new(options.merge(name: name)).generate
+    end
+
+    desc "summary STACK", "Prints summary of CloudFormation template"
+    long_desc Help.text("summary")
+    def summary(name)
+      Lono::Inspector::Summary.new(name, options).run
+    end
+
+    desc "xgraph STACK", "Graphs dependencies tree of CloudFormation template resources"
+    long_desc Help.text("graph")
+    option :display, type: :string, desc: "graph or text", default: "graph"
+    option :noop, type: :boolean, desc: "noop mode"
+    def xgraph(name)
+      Lono::Inspector::Graph.new(name, options).run
     end
 
     desc "clean", "Clean up generated files"
     def clean
-      Lono::Clean.new(options.clone).run
+      Clean.new(options).run
+    end
+
+    desc "completion *PARAMS", "prints words for auto-completion"
+    long_desc Help.text("completion")
+    def completion(*params)
+      Completer.new(CLI, *params).run
+    end
+
+    desc "completion_script", "generates script that can be eval to setup auto-completion", hide: true
+    long_desc Help.text("completion_script")
+    def completion_script
+      Completer::Script.generate
+    end
+
+    desc "upgrade4", "upgrade from version 3 to 4"
+    long_desc Help.text("upgrade3")
+    def upgrade4
+      Upgrade4.new(options).run
     end
 
     desc "version", "Prints version"
     def version
-      puts Lono::VERSION
+      puts VERSION
     end
 
-    desc "template ACTION", "template subcommand tasks"
-    long_desc Help.template
+    desc "template SUBCOMMAND", "template subcommand tasks"
+    long_desc Help.text(:template)
     subcommand "template", Template
 
-    desc "cfn ACTION", "cfn subcommand tasks"
-    long_desc Help.cfn
+    desc "cfn SUBCOMMAND", "cfn subcommand tasks"
+    long_desc Help.text(:cfn)
     subcommand "cfn", Cfn
 
-    desc "param ACTION", "param subcommand tasks"
-    long_desc Help.param
-    subcommand "param", Lono::Param
+    desc "param SUBCOMMAND", "param subcommand tasks"
+    long_desc Help.text(:param)
+    subcommand "param", Param
 
-    desc "inspect ACTION", "inspect subcommand tasks"
-    long_desc Help.inspector
-    subcommand "inspect", Inspector
+    desc "script SUBCOMMAND", "script subcommand tasks"
+    long_desc Help.text(:script)
+    subcommand "script", Script
   end
 end

data/lib/lono/command.rb

@@ -1,23 +1,47 @@
-require 'thor'
+require "thor"
 
-class Lono::Command < Thor
-  class << self
-    def dispatch(m, args, options, config)
-      # Allow calling for help via:
-      #   lono generate help
-      #   lono generate -h
-      #   lono generate --help
-      #   lono generate -D
-      #
-      # as well thor's nomral setting as
-      #
-      #   lono help generate
-      help_flags = Thor::HELP_MAPPINGS + ["help"]
-      if args.length > 1 && !(args & help_flags).empty?
-        args -= help_flags
-        args.insert(-2, "help")
+# Override thor's long_desc identation behavior
+# https://github.com/erikhuda/thor/issues/398
+class Thor
+  module Shell
+    class Basic
+      def print_wrapped(message, options = {})
+        message = "\n#{message}" unless message[0] == "\n"
+        stdout.puts message
+      end
+    end
+  end
+end
+
+module Lono
+  class Command < Thor
+    class << self
+      def dispatch(m, args, options, config)
+        # Allow calling for help via:
+        #   lono command help
+        #   lono command -h
+        #   lono command --help
+        #   lono command -D
+        #
+        # as well thor's normal way:
+        #
+        #   lono help command
+        help_flags = Thor::HELP_MAPPINGS + ["help"]
+        if args.length > 1 && !(args & help_flags).empty?
+          args -= help_flags
+          args.insert(-2, "help")
+        end
+
+        #   lono version
+        #   lono --version
+        #   lono -v
+        version_flags = ["--version", "-v"]
+        if args.length == 1 && !(args & version_flags).empty?
+          args = ["version"]
+        end
+
+        super
       end
-      super
     end
   end
 end

data/lib/lono/completer.rb

@@ -0,0 +1,162 @@
+=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 development
+
+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:
+
+  lono completion
+  lono completion hello
+  lono completion hello name
+  lono completion hello name --
+  lono completion hello name --noop
+
+  lono completion
+  lono completion sub:goodbye
+  lono 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 Lono
+  class Completer
+    autoload :Script, 'lono/completer/script'
+
+    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
+      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