aws-ec2 0.9.0 → 1.0.0

data/lib/aws_ec2/command.rb

@@ -18,21 +18,50 @@ module AwsEc2
     class << self
       def dispatch(m, args, options, config)
         # Allow calling for help via:
-        #   aws_ec2 command help
-        #   aws_ec2 command -h
-        #   aws_ec2 command --help
-        #   aws_ec2 command -D
+        #   aws-ec2 command help
+        #   aws-ec2 command -h
+        #   aws-ec2 command --help
+        #   aws-ec2 command -D
         #
         # as well thor's normal way:
         #
-        #   aws_ec2 help command
+        #   aws-ec2 help command
         help_flags = Thor::HELP_MAPPINGS + ["help"]
         if args.length > 1 && !(args & help_flags).empty?
           args -= help_flags
           args.insert(-2, "help")
         end
+
+        #   aws-ec2 version
+        #   aws-ec2 --version
+        #   aws-ec2 -v
+        version_flags = ["--version", "-v"]
+        if args.length == 1 && !(args & version_flags).empty?
+          args = ["version"]
+        end
+
+        super
+      end
+
+      # Override command_help to include the description at the top of the
+      # long_description.
+      def command_help(shell, command_name)
+        meth = normalize_command_name(command_name)
+        command = all_commands[meth]
+        alter_command_description(command)
         super
       end
+
+      def alter_command_description(command)
+        return unless command
+        long_desc = if command.long_description
+            "#{command.description}\n\n#{command.long_description}"
+          else
+            command.description
+          end
+        command.long_description = long_desc
+      end
+      private :alter_command_description
     end
   end
 end

data/lib/aws_ec2/completer.rb

@@ -0,0 +1,161 @@
+=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:
+
+  aws-ec2 completion
+  aws-ec2 completion hello
+  aws-ec2 completion hello name
+  aws-ec2 completion hello name --
+  aws-ec2 completion hello name --noop
+
+  aws-ec2 completion
+  aws-ec2 completion sub:goodbye
+  aws-ec2 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 AwsEc2
+  class Completer
+    autoload :Script, 'aws_ec2/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
+      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/aws_ec2/completer/script.rb

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

data/lib/aws_ec2/completer/script.sh

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

data/lib/aws_ec2/config.rb

@@ -7,8 +7,10 @@ module AwsEc2
       @path = options[:path] || "#{AwsEc2.root}/config/#{AwsEc2.env}.yml"
     end
 
-    def settings
-      YAML.load_file(@path)
+    @@data = nil
+    def data
+      return @@data if @@data
+      @@data = YAML.load_file(@path)
     rescue Errno::ENOENT => e
       puts e.message
       puts "The #{@path} does not exist. Please double check that it exists."

data/lib/aws_ec2/core.rb

@@ -4,7 +4,11 @@ module AwsEc2
   module Core
     @@config = nil
     def config
-      @@config ||= Config.new.settings
+      @@config ||= Config.new.data
+    end
+
+    def settings
+      Setting.new.data
     end
 
     def env

data/lib/aws_ec2/create.rb

@@ -10,22 +10,25 @@ module AwsEc2
     include ErrorMessages
 
     def run
-      puts "Creating EC2 instance #{@options[:name]}..."
+      Profile.new(@options).check!
+
+      puts "Creating EC2 instance #{@name}..."
       display_info
+
+      Hook.run(:before_run_instances, @options)
+      sync_scripts_to_s3
+
       if @options[:noop]
         puts "NOOP mode enabled. EC2 instance not created."
         return
       end
-
-      Hook.run(:before_run_instances, @options)
-      sync_scripts_to_s3
       run_instances(params)
-      puts "EC2 instance #{@options[:name]} created! 🎉"
+      puts "EC2 instance #{@name} created! 🎉"
       puts "Visit https://console.aws.amazon.com/ec2/home to check on the status"
     end
 
     def run_instances(params)
-      resp = ec2.run_instances(params)
+      ec2.run_instances(params)
     rescue Aws::EC2::Errors::ServiceError => e
       handle_ec2_service_error!(e)
     end
@@ -35,8 +38,8 @@ module AwsEc2
     #
     #   scripts_s3_bucket: my-bucket
     def sync_scripts_to_s3
-      if AwsEc2.config["scripts_s3_bucket"]
-        Script::Upload.new(@options).upload
+      if AwsEc2.settings["s3_folder"]
+        Script::Upload.new(@options).run
       end
     end
 

data/lib/aws_ec2/create/error_messages.rb

@@ -20,7 +20,7 @@ EOL
     #   Aws::EC2::Errors::InvalidParameterCombination => invalid_parameter_combination!
     def map_exception_to_method(exception)
       class_name = File.basename(exception.class.to_s).sub(/.*::/,'')
-      method_name = class_name.underscore
+      class_name.underscore # method_name
     end
 
     def print_error_message(exception, message)

data/lib/aws_ec2/create/params.rb

@@ -1,9 +1,5 @@
 class AwsEc2::Create
-  class Params
-    def initialize(options)
-      @options = options
-    end
-
+  class Params < AwsEc2::Base
     # deep_symbolize_keys is ran at the very end only.
     # up until that point we're dealing with String keys.
     def generate
@@ -52,7 +48,7 @@ class AwsEc2::Create
       tags = spec["tags"] || []
 
       unless tags.map { |t| t["key"] }.include?("Name")
-        tags << { "key" => "Name", "value" => @options[:name] }
+        tags << { "key" => "Name", "value" => @name }
       end
 
       specs = specs.map do |s|

data/lib/aws_ec2/help/completion.md

@@ -0,0 +1,22 @@
+Example:
+
+  aws-ec2 completion
+
+Prints words for TAB auto-completion.
+
+Examples:
+
+  aws-ec2 completion
+  aws-ec2 completion hello
+  aws-ec2 completion hello name
+
+To enable, TAB auto-completion add the following to your profile:
+
+  eval $(aws-ec2 completion_script)
+
+Auto-completion example usage:
+
+  aws-ec2 [TAB]
+  aws-ec2 hello [TAB]
+  aws-ec2 hello name [TAB]
+  aws-ec2 hello name --[TAB]

data/lib/aws_ec2/help/completion_script.md

@@ -0,0 +1,3 @@
+To use, add the following to your `~/.bashrc` or `~/.profile`
+
+    eval $(aws-ec2 completion_script)

data/lib/aws_ec2/profile.rb

@@ -1,48 +1,55 @@
 module AwsEc2
-  class Profile
-    include TemplateHelper
-
-    def initialize(options)
-      @options = options
-    end
+  class Profile < Base
+    include AwsEc2::Template
 
     def load
       return @profile_params if @profile_params
 
       check!
 
-      @profile_params = load_profile(profile_file)
+      file = profile_file(profile_name)
+      @profile_params = load_profile(file)
     end
 
     def check!
-      return if File.exist?(profile_file)
+      file = profile_file(profile_name)
+      return if File.exist?(file)
 
-      puts "Unable to find a #{profile_file.colorize(:green)} profile file."
-      puts "Please double check that it exists or that you specified the right profile."
-      exit # EXIT HERE
+      puts "Unable to find a #{file.colorize(:green)} profile file."
+      puts "Please double check that it exists or that you specified the right profile.".colorize(:red)
+      exit 1
     end
 
     def load_profile(file)
       return {} unless File.exist?(file)
 
       puts "Using profile: #{file}".colorize(:green)
-      data = YAML.load(erb_result(file))
+      text = RenderMePretty.result(file, context: context)
+      data = YAML.load(text)
       data ? data : {} # in case the file is empty
       data.has_key?("run_instances") ? data["run_instances"] : data
     end
 
-    def profile_file
-      "#{AwsEc2.root}/profiles/#{profile_name}.yml"
-    end
-
+    # Determines a valid profile_name. Falls back to default
     def profile_name
       # allow user to specify the path also
       if @options[:profile] && File.exist?(@options[:profile])
-        profile = File.basename(@options[:profile], '.yml')
+        filename_profile = File.basename(@options[:profile], '.yml')
       end
 
-      # conventional profile is the name of the ec2 instance
-      profile || @options[:profile] || "default"
+      name = derandomize(@name)
+      if File.exist?(profile_file(name))
+        name_profile = name
+      end
+
+      filename_profile ||
+      @options[:profile] ||
+      name_profile || # conventional profile is the name of the ec2 instance
+      "default"
+    end
+
+    def profile_file(name)
+      "#{AwsEc2.root}/profiles/#{name}.yml"
     end
   end
 end

data/lib/aws_ec2/script.rb

@@ -1,6 +1,7 @@
 module AwsEc2
   class Script
     autoload :Compile, "aws_ec2/script/compile"
+    autoload :Compress, "aws_ec2/script/compress"
     autoload :Upload, "aws_ec2/script/upload"
 
     def initialize(options={})