cody 0.1.0 → 0.7.0

data/exe/cody

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+# Trap ^C
+Signal.trap("INT") {
+  puts "\nCtrl-C detected. Exiting..."
+  sleep 0.1
+  exit
+}
+
+$:.unshift(File.expand_path("../../lib", __FILE__))
+require "cody"
+require "cody/cli"
+
+Cody::CLI.start(ARGV)

data/lib/cody.rb

@@ -1,6 +1,22 @@
+$:.unshift(File.expand_path("../", __FILE__))
 require "cody/version"
+require "rainbow/ext/string"
+require "yaml"
+
+require "cody/autoloader"
+Cody::Autoloader.setup
+
+gem_root = File.dirname(__dir__)
+$:.unshift("#{gem_root}/vendor/aws_data/lib")
+require "aws_data"
+$:.unshift("#{gem_root}/vendor/cfn_camelizer/lib")
+require "cfn_camelizer"
+$:.unshift("#{gem_root}/vendor/cfn-status/lib")
+require "cfn/status"
 
 module Cody
   class Error < StandardError; end
-  # Your code goes here...
+  extend Core
 end
+
+Cody.set_aws_profile!

data/lib/cody/autoloader.rb

@@ -0,0 +1,21 @@
+require "zeitwerk"
+
+module Cody
+  class Autoloader
+    class Inflector < Zeitwerk::Inflector
+      def camelize(basename, _abspath)
+        map = { cli: "CLI", version: "VERSION" }
+        map[basename.to_sym] || super
+      end
+    end
+
+    class << self
+      def setup
+        loader = Zeitwerk::Loader.new
+        loader.inflector = Inflector.new
+        loader.push_dir(File.dirname(__dir__)) # lib
+        loader.setup
+      end
+    end
+  end
+end

data/lib/cody/aws_services.rb

@@ -0,0 +1,16 @@
+require "aws-sdk-codebuild"
+require "aws-sdk-cloudformation"
+
+module Cody
+  module AwsServices
+    include Helpers
+
+    def codebuild
+      @codebuild ||= Aws::CodeBuild::Client.new
+    end
+
+    def cfn
+      @cfn ||= Aws::CloudFormation::Client.new
+    end
+  end
+end

data/lib/cody/aws_services/helpers.rb

@@ -0,0 +1,72 @@
+module Cody::AwsServices
+  module Helpers
+    def stack_exists?(stack_name)
+      return false if ENV['TEST']
+
+      exist = nil
+      begin
+        # When the stack does not exist an exception is raised. Example:
+        # Aws::CloudFormation::Errors::ValidationError: Stack with id blah does not exist
+        cfn.describe_stacks(stack_name: stack_name)
+        exist = true
+      rescue Aws::CloudFormation::Errors::ValidationError => e
+        if e.message =~ /does not exist/
+          exist = false
+        elsif e.message.include?("'stackName' failed to satisfy constraint")
+          # Example of e.message when describe_stack with invalid stack name
+          # "1 validation error detected: Value 'instance_and_route53' at 'stackName' failed to satisfy constraint: Member must satisfy regular expression pattern: [a-zA-Z][-a-zA-Z0-9]*|arn:[-a-zA-Z0-9:/._+]*"
+          puts "Invalid stack name: #{stack_name}"
+          puts "Full error message: #{e.message}"
+          exit 1
+        else
+          raise # re-raise exception  because unsure what other errors can happen
+        end
+      end
+      exist
+    end
+
+    def project_name_convention(name_base)
+      items = [@project_name, @options[:type], Cody.env_extra]
+      items.insert(2, Cody.env) if Cody.settings.dig(:stack_naming, :append_env)
+      items.reject(&:blank?).compact.join("-")
+    end
+
+    def inferred_project_name
+      # Essentially the project's parent folder
+      File.basename(Dir.pwd).gsub('_','-').gsub(/\.+/,'-').gsub(/[^0-9a-zA-Z,-]/, '')
+    end
+
+    # Examples:
+    #
+    #     myapp-ci-deploy # with Settings stack_naming append_env set to false.
+    #     myapp-ci-deploy-development
+    #     myapp-ci-deploy-development-2
+    #
+    def inferred_stack_name(project_name)
+      append_stack_name = Cody.settings.dig(:stack_naming, :append_stack_name) || "cody"
+      items = [project_name, @options[:type], Cody.env_extra, append_stack_name]
+      items.insert(3, Cody.env) if Cody.settings.dig(:stack_naming, :append_env)
+      items.reject(&:blank?).reject {|i| i == false}.compact.join("-")
+    end
+
+    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_name.color(:green)} stack with the changes? (y/N)"
+        when :delete
+          "Are you sure you want to want to delete the #{stack_name.color(:green)} stack? (y/N)"
+        end
+        puts message
+        sure = $stdin.gets
+      end
+
+      unless sure =~ /^y/
+        puts "Whew! Exiting without running #{action}."
+        exit 0
+      end
+    end
+  end
+end

data/lib/cody/cli.rb

@@ -0,0 +1,61 @@
+module Cody
+  class CLI < Command
+    class_option :verbose, type: :boolean
+    class_option :noop, type: :boolean
+
+    desc "init", "Initialize project with .cody files"
+    long_desc Help.text(:init)
+    Init.cli_options.each do |args|
+      option(*args)
+    end
+    register(Init, "init", "init", "Set up initial .cody files.")
+
+    common_options = Proc.new do
+      option :type, desc: "folder to use within .cody folder for different build types"
+      option :stack_name, desc: "Override the generated stack name. If you use this you must always specify it"
+      option :wait, type: :boolean, default: true, desc: "Wait for operation to complete"
+    end
+
+    desc "deploy", "Deploy codebuild project."
+    long_desc Help.text(:deploy)
+    common_options.call
+    def deploy(project_name=nil)
+      Deploy.new(options.merge(project_name: project_name)).run
+    end
+
+    desc "delete", "Delete codebuild project."
+    long_desc Help.text(:delete)
+    option :sure, desc: "Bypass are you sure prompt"
+    common_options.call
+    def delete(project_name=nil)
+      Delete.new(options.merge(project_name: project_name)).run
+    end
+
+    desc "start", "start codebuild project."
+    long_desc Help.text(:start)
+    option :source_version, default: "master", desc: "git branch"
+    option :branch, aliases: "b", default: "master", desc: "git branch"
+    option :env_vars, type: :array, desc: "env var overrides. IE: KEY1=VALUE1 KEY2=VALUE2"
+    common_options.call
+    def start(project_name=nil)
+      Start.new(options.merge(project_name: project_name)).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 a script that can be eval to setup auto-completion."
+    long_desc Help.text(:completion_script)
+    def completion_script
+      Completer::Script.generate
+    end
+
+    desc "version", "prints version"
+    def version
+      puts VERSION
+    end
+  end
+end

data/lib/cody/command.rb

@@ -0,0 +1,82 @@
+require "thor"
+
+# 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 Cody
+  class Command < Thor
+    class << self
+      def dispatch(m, args, options, config)
+        # Allow calling for help via:
+        #   codebuild command help
+        #   codebuild command -h
+        #   codebuild command --help
+        #   codebuild command -D
+        #
+        # as well thor's normal way:
+        #
+        #   codebuild help command
+        help_flags = Thor::HELP_MAPPINGS + ["help"]
+        if args.length > 1 && !(args & help_flags).empty?
+          args -= help_flags
+          args.insert(-2, "help")
+        end
+
+        #   codebuild version
+        #   codebuild --version
+        #   codebuild -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
+
+        # Add description to beginning of long_description
+        long_desc = if command.long_description
+            "#{command.description}\n\n#{command.long_description}"
+          else
+            command.description
+          end
+
+        # add reference url to end of the long_description
+        unless website.empty?
+          full_command = [command.ancestor_name, command.name].compact.join('-')
+          url = "#{website}/reference/codebuild-#{full_command}"
+          long_desc += "\n\nHelp also available at: #{url}"
+        end
+
+        command.long_description = long_desc
+      end
+      private :alter_command_description
+
+      # meant to be overriden
+      def website
+        ""
+      end
+    end
+  end
+end

data/lib/cody/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 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:
+
+  codebuild completion
+  codebuild completion hello
+  codebuild completion hello name
+  codebuild completion hello name --
+  codebuild completion hello name --noop
+
+  codebuild completion
+  codebuild completion sub:goodbye
+  codebuild 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 Cody
+  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